home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / puma.lha / puma / m2c / Tree.c < prev    next >
C/C++ Source or Header  |  1992-09-25  |  203KB  |  7,477 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_System
  4. #include "System.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_General
  8. #include "General.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_Memory
  12. #include "Memory.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_DynArray
  16. #include "DynArray.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_IO
  20. #include "IO.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_Layout
  24. #include "Layout.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_StringMem
  28. #include "StringMem.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_Strings
  32. #include "Strings.h"
  33. #endif
  34.  
  35. #ifndef DEFINITION_Idents
  36. #include "Idents.h"
  37. #endif
  38.  
  39. #ifndef DEFINITION_Texts
  40. #include "Texts.h"
  41. #endif
  42.  
  43. #ifndef DEFINITION_Sets
  44. #include "Sets.h"
  45. #endif
  46.  
  47. #ifndef DEFINITION_Positions
  48. #include "Positions.h"
  49. #endif
  50.  
  51. #ifndef DEFINITION_DynArray
  52. #include "DynArray.h"
  53. #endif
  54.  
  55. #ifndef DEFINITION_IO
  56. #include "IO.h"
  57. #endif
  58.  
  59. #ifndef DEFINITION_Strings
  60. #include "Strings.h"
  61. #endif
  62.  
  63. #ifndef DEFINITION_StringMem
  64. #include "StringMem.h"
  65. #endif
  66.  
  67. #ifndef DEFINITION_Idents
  68. #include "Idents.h"
  69. #endif
  70.  
  71. #ifndef DEFINITION_Texts
  72. #include "Texts.h"
  73. #endif
  74.  
  75. #ifndef DEFINITION_Sets
  76. #include "Sets.h"
  77. #endif
  78.  
  79. #ifndef DEFINITION_Relations
  80. #include "Relations.h"
  81. #endif
  82.  
  83. #ifndef DEFINITION_Positions
  84. #include "Positions.h"
  85. #endif
  86.  
  87. #ifndef DEFINITION_Relations
  88. #include "Relations.h"
  89. #endif
  90.  
  91. #ifndef DEFINITION_Errors
  92. #include "Errors.h"
  93. #endif
  94.  
  95. #ifndef DEFINITION_Tree
  96. #include "Tree.h"
  97. #endif
  98.  
  99. CARDINAL Tree_ErrorCount;
  100. Sets_tSet Tree_Options;
  101. IO_tFile Tree_f;
  102. struct Tree_1 Tree_SourceFile;
  103. BITSET Tree_NoCodeAttr, Tree_NoCodeClass;
  104. Tree_tTree Tree_TreeRoot;
  105. LONGCARD Tree_HeapUsed;
  106. ADDRESS Tree_yyPoolFreePtr, Tree_yyPoolMaxPtr;
  107. struct Tree_108 Tree_yyNodeSize;
  108. PROC Tree_yyExit;
  109.  
  110. static struct S_3 {
  111.     Tree_tTree A[1000000 + 1];
  112. } *IdentToClassPtr;
  113. static LONGINT IdentToClassSize;
  114. static Idents_tIdent sIdentToClassSize;
  115. #define yyBlockSize    20480
  116. typedef struct S_1 *yytBlockPtr;
  117. typedef struct S_1 {
  118.     struct S_4 {
  119.         CHAR A[yyBlockSize - 1 + 1];
  120.     } yyBlock;
  121.     yytBlockPtr yySuccessor;
  122. } yytBlock;
  123. static yytBlockPtr yyBlockList;
  124. static SHORTCARD yyMaxSize, yyi;
  125. static struct S_5 {
  126.     SHORTCARD A[129 + 1];
  127. } yyTypeRange;
  128. typedef Tree_tTree *yyPtrtTree;
  129. static IO_tFile yyf;
  130. static SHORTCARD yyLabel;
  131. static SHORTCARD yyKind;
  132. static CHAR yyc;
  133. static Strings_tString yys;
  134. static void yyMark ARGS((Tree_tTree yyt));
  135. static void yyWriteNl ARGS(());
  136. static void yyWriteSelector ARGS((CHAR yys[], LONGCARD ));
  137. static void yyWriteHex ARGS((BYTE yyx[], LONGCARD ));
  138. static void yyWriteAdr ARGS((Tree_tTree yyt));
  139. static void yWriteNodeClass ARGS((Tree_tTree yyt));
  140. static void yWriteNodeAttrOrAction ARGS((Tree_tTree yyt));
  141. static void yWriteNodeChild ARGS((Tree_tTree yyt));
  142. static void yWriteNodeAttribute ARGS((Tree_tTree yyt));
  143. static void yWriteNodeActionPart ARGS((Tree_tTree yyt));
  144. static void yWriteNodeCodes ARGS((Tree_tTree yyt));
  145. static void yWriteNodeDesignator ARGS((Tree_tTree yyt));
  146. static void yWriteNodeIdent ARGS((Tree_tTree yyt));
  147. static void yWriteNodeRemote ARGS((Tree_tTree yyt));
  148. static void yWriteNodeAny ARGS((Tree_tTree yyt));
  149. static void yWriteNodeAnys ARGS((Tree_tTree yyt));
  150. static void yWriteNodeLayoutAny ARGS((Tree_tTree yyt));
  151. static void yWriteNodeName ARGS((Tree_tTree yyt));
  152. static void yWriteNodeSpec ARGS((Tree_tTree yyt));
  153. static void yWriteNodeTreeName ARGS((Tree_tTree yyt));
  154. static void yWriteNodeRoutine ARGS((Tree_tTree yyt));
  155. static void yWriteNodeProcedure ARGS((Tree_tTree yyt));
  156. static void yWriteNodeFunction ARGS((Tree_tTree yyt));
  157. static void yWriteNodePredicate ARGS((Tree_tTree yyt));
  158. static void yWriteNodeParam ARGS((Tree_tTree yyt));
  159. static void yWriteNodeType ARGS((Tree_tTree yyt));
  160. static void yWriteNodeRule ARGS((Tree_tTree yyt));
  161. static void yWriteNodeNoPattern ARGS((Tree_tTree yyt));
  162. static void yWriteNodeOnePattern ARGS((Tree_tTree yyt));
  163. static void yWriteNodeOnePatternsList ARGS((Tree_tTree yyt));
  164. static void yWriteNodePattern ARGS((Tree_tTree yyt));
  165. static void yWriteNodeDecompose ARGS((Tree_tTree yyt));
  166. static void yWriteNodeVarDef ARGS((Tree_tTree yyt));
  167. static void yWriteNodeNilTest ARGS((Tree_tTree yyt));
  168. static void yWriteNodeDontCare1 ARGS((Tree_tTree yyt));
  169. static void yWriteNodeDontCare ARGS((Tree_tTree yyt));
  170. static void yWriteNodeValue ARGS((Tree_tTree yyt));
  171. static void yWriteNodeNoExpr ARGS((Tree_tTree yyt));
  172. static void yWriteNodeOneExpr ARGS((Tree_tTree yyt));
  173. static void yWriteNodeNamedExpr ARGS((Tree_tTree yyt));
  174. static void yWriteNodeExpr ARGS((Tree_tTree yyt));
  175. static void yWriteNodeCompose ARGS((Tree_tTree yyt));
  176. static void yWriteNodeVarUse ARGS((Tree_tTree yyt));
  177. static void yWriteNodeAttrDesc ARGS((Tree_tTree yyt));
  178. static void yWriteNodeNil ARGS((Tree_tTree yyt));
  179. static void yWriteNodeCall ARGS((Tree_tTree yyt));
  180. static void yWriteNodeBinary ARGS((Tree_tTree yyt));
  181. static void yWriteNodePreOperator ARGS((Tree_tTree yyt));
  182. static void yWriteNodePostOperator ARGS((Tree_tTree yyt));
  183. static void yWriteNodeIndex ARGS((Tree_tTree yyt));
  184. static void yWriteNodeParents ARGS((Tree_tTree yyt));
  185. static void yWriteNodeTargetExpr ARGS((Tree_tTree yyt));
  186. static void yWriteNodeStringExpr ARGS((Tree_tTree yyt));
  187. static void yWriteNodeStatement ARGS((Tree_tTree yyt));
  188. static void yWriteNodeProcCall ARGS((Tree_tTree yyt));
  189. static void yWriteNodeCondition ARGS((Tree_tTree yyt));
  190. static void yWriteNodeAssignment ARGS((Tree_tTree yyt));
  191. static void yWriteNodeReject ARGS((Tree_tTree yyt));
  192. static void yWriteNodeFail ARGS((Tree_tTree yyt));
  193. static void yWriteNodeTargetStmt ARGS((Tree_tTree yyt));
  194. static void yWriteNodeNl ARGS((Tree_tTree yyt));
  195. static void yWriteNodeWriteStr ARGS((Tree_tTree yyt));
  196. static void yWriteNodeFormal ARGS((Tree_tTree yyt));
  197. static void yWriteNodeDummyFormal ARGS((Tree_tTree yyt));
  198. static void yWriteNodeNodeTypes ARGS((Tree_tTree yyt));
  199. static void yWriteNodeUserType ARGS((Tree_tTree yyt));
  200. static void yWriteNodeVar ARGS((Tree_tTree yyt));
  201. static void yWriteNodeConsType ARGS((Tree_tTree yyt));
  202. static void yWriteNodeField ARGS((Tree_tTree yyt));
  203. static void yWriteNodeOneTest ARGS((Tree_tTree yyt));
  204. static void yWriteNodeTestKind ARGS((Tree_tTree yyt));
  205. static void yWriteNodeTestIsType ARGS((Tree_tTree yyt));
  206. static void yWriteNodeTestNil ARGS((Tree_tTree yyt));
  207. static void yWriteNodeTestNonlin ARGS((Tree_tTree yyt));
  208. static void yWriteNodeTestValue ARGS((Tree_tTree yyt));
  209. static void yWriteNodeDecision ARGS((Tree_tTree yyt));
  210. static void yWriteNodeDecided ARGS((Tree_tTree yyt));
  211. #define yyNil    ((CHAR)'\374')
  212. #define yyNoLabel    ((CHAR)'\375')
  213. #define yyLabelDef    ((CHAR)'\376')
  214. #define yyLabelUse    ((CHAR)'\377')
  215. #define yyInitOldToNewStoreSize    32
  216. typedef struct S_2 {
  217.     Tree_tTree yyOld, yyNew;
  218. } yytOldToNew;
  219. static LONGINT yyOldToNewStoreSize;
  220. static struct S_8 {
  221.     yytOldToNew A[50000 + 1];
  222. } *yyOldToNewStorePtr;
  223. static INTEGER yyOldToNewCount;
  224. static void yyStoreOldToNew ARGS((Tree_tTree yyOld, Tree_tTree yyNew));
  225. static Tree_tTree yyMapOldToNew ARGS((Tree_tTree yyOld));
  226. static void yyCopyTree ARGS((Tree_tTree yyt, yyPtrtTree yyNew));
  227. #define yyyWrite    1
  228. #define yyyRead    2
  229. #define yyyQuit    3
  230. static struct S_9 {
  231.     CHAR A[31 + 1];
  232. } yyString;
  233. static INTEGER yyLength;
  234. static CHAR yyCh;
  235. static INTEGER yyState;
  236. static BOOLEAN yyyIsEqual ARGS((CHAR yya[], LONGCARD ));
  237. static void xxExit ARGS(());
  238.  
  239.  
  240. void Tree_InitIdentifyClass
  241. # ifdef __STDC__
  242. (Tree_tTree t)
  243. # else
  244. (t)
  245. Tree_tTree t;
  246. # endif
  247. {
  248.   INTEGER i;
  249.  
  250.   IdentToClassSize = Idents_MaxIdent() + 1;
  251.   sIdentToClassSize = IdentToClassSize;
  252.   DynArray_MakeArray((ADDRESS *)&IdentToClassPtr, &IdentToClassSize, (LONGINT)sizeof(Tree_tTree));
  253.   {
  254.     LONGINT B_1 = 0, B_2 = IdentToClassSize - 1;
  255.  
  256.     if (B_1 <= B_2)
  257.       for (i = B_1;; i += 1) {
  258.         IdentToClassPtr->A[i] = Tree_NoTree;
  259.         if (i >= B_2) break;
  260.       }
  261.   }
  262.   Tree_ForallClasses(t, (Tree_ProcOfT)Tree_InitIdentifyClass2);
  263. }
  264.  
  265. void Tree_InitIdentifyClass2
  266. # ifdef __STDC__
  267. (Tree_tTree t)
  268. # else
  269. (t)
  270. Tree_tTree t;
  271. # endif
  272. {
  273.   IdentToClassPtr->A[t->U_1.V_5.Class.Name] = t;
  274. }
  275.  
  276. Tree_tTree Tree_IdentifyClass
  277. # ifdef __STDC__
  278. (Tree_tTree t, Idents_tIdent Ident)
  279. # else
  280. (t, Ident)
  281. Tree_tTree t;
  282. Idents_tIdent Ident;
  283. # endif
  284. {
  285.   if (Ident < sIdentToClassSize) {
  286.     return IdentToClassPtr->A[Ident];
  287.   }
  288.   return Tree_NoTree;
  289. }
  290.  
  291. Tree_tTree Tree_IdentifyAttribute
  292. # ifdef __STDC__
  293. (Tree_tTree t, Idents_tIdent Ident)
  294. # else
  295. (t, Ident)
  296. Tree_tTree t;
  297. Idents_tIdent Ident;
  298. # endif
  299. {
  300.   Tree_tTree attribute;
  301.  
  302.   for (;;) {
  303.     switch (t->U_1.V_1.Kind) {
  304.     case Tree_Class:;
  305.       attribute = Tree_IdentifyAttribute(t->U_1.V_5.Class.BaseClass, Ident);
  306.       if (attribute != Tree_NoTree) {
  307.         return attribute;
  308.       }
  309.       t = t->U_1.V_5.Class.Attributes;
  310.       break;
  311.     case Tree_Child:;
  312.       if (t->U_1.V_9.Child.Name == Ident) {
  313.         return t;
  314.       }
  315.       t = t->U_1.V_9.Child.Next;
  316.       break;
  317.     case Tree_Attribute:;
  318.       if (t->U_1.V_10.Attribute.Name == Ident) {
  319.         return t;
  320.       }
  321.       t = t->U_1.V_10.Attribute.Next;
  322.       break;
  323.     case Tree_ActionPart:;
  324.       t = t->U_1.V_11.ActionPart.Next;
  325.       break;
  326.     default :
  327.       return Tree_NoTree;
  328.       break;
  329.     }
  330.   } EXIT_1:;
  331. }
  332.  
  333. void Tree_ForallClasses
  334. # ifdef __STDC__
  335. (Tree_tTree t, Tree_ProcOfT Proc)
  336. # else
  337. (t, Proc)
  338. Tree_tTree t;
  339. Tree_ProcOfT Proc;
  340. # endif
  341. {
  342.   while (t->U_1.V_1.Kind == Tree_Class) {
  343.     (*Proc)(t);
  344.     Tree_ForallClasses(t->U_1.V_5.Class.Extensions, Proc);
  345.     t = t->U_1.V_5.Class.Next;
  346.   }
  347. }
  348.  
  349. void Tree_ForallAttributes
  350. # ifdef __STDC__
  351. (Tree_tTree t, Tree_ProcOfT Proc)
  352. # else
  353. (t, Proc)
  354. Tree_tTree t;
  355. Tree_ProcOfT Proc;
  356. # endif
  357. {
  358.   for (;;) {
  359.     switch (t->U_1.V_1.Kind) {
  360.     case Tree_Class:;
  361.       Tree_ForallAttributes(t->U_1.V_5.Class.BaseClass, Proc);
  362.       t = t->U_1.V_5.Class.Attributes;
  363.       break;
  364.     case Tree_Child:;
  365.       (*Proc)(t);
  366.       t = t->U_1.V_9.Child.Next;
  367.       break;
  368.     case Tree_Attribute:;
  369.       (*Proc)(t);
  370.       t = t->U_1.V_10.Attribute.Next;
  371.       break;
  372.     case Tree_ActionPart:;
  373.       (*Proc)(t);
  374.       t = t->U_1.V_11.ActionPart.Next;
  375.       break;
  376.     default :
  377.       return;
  378.       break;
  379.     }
  380.   } EXIT_2:;
  381. }
  382.  
  383. void Tree_Error
  384. # ifdef __STDC__
  385. (INTEGER ErrorCode, Positions_tPosition Pos)
  386. # else
  387. (ErrorCode, Pos)
  388. INTEGER ErrorCode;
  389. Positions_tPosition Pos;
  390. # endif
  391. {
  392.   Errors_ErrorMessage((LONGCARD)ErrorCode, (LONGCARD)Errors_Error, Pos);
  393.   INC(Tree_ErrorCount);
  394. }
  395.  
  396. void Tree_Warning
  397. # ifdef __STDC__
  398. (INTEGER ErrorCode, Positions_tPosition Pos)
  399. # else
  400. (ErrorCode, Pos)
  401. INTEGER ErrorCode;
  402. Positions_tPosition Pos;
  403. # endif
  404. {
  405.   Errors_ErrorMessage((LONGCARD)ErrorCode, (LONGCARD)Errors_Warning, Pos);
  406. }
  407.  
  408. void Tree_Information
  409. # ifdef __STDC__
  410. (INTEGER ErrorCode, Positions_tPosition Pos)
  411. # else
  412. (ErrorCode, Pos)
  413. INTEGER ErrorCode;
  414. Positions_tPosition Pos;
  415. # endif
  416. {
  417.   Errors_ErrorMessage((LONGCARD)ErrorCode, (LONGCARD)Errors_Information, Pos);
  418. }
  419.  
  420. void Tree_ErrorI
  421. # ifdef __STDC__
  422. (INTEGER ErrorCode, Positions_tPosition Pos, INTEGER iClass, ADDRESS iPtr)
  423. # else
  424. (ErrorCode, Pos, iClass, iPtr)
  425. INTEGER ErrorCode;
  426. Positions_tPosition Pos;
  427. INTEGER iClass;
  428. ADDRESS iPtr;
  429. # endif
  430. {
  431.   Errors_ErrorMessageI((LONGCARD)ErrorCode, (LONGCARD)Errors_Error, Pos, (LONGCARD)iClass, iPtr);
  432.   INC(Tree_ErrorCount);
  433. }
  434.  
  435. void Tree_WarningI
  436. # ifdef __STDC__
  437. (INTEGER ErrorCode, Positions_tPosition Pos, INTEGER iClass, ADDRESS iPtr)
  438. # else
  439. (ErrorCode, Pos, iClass, iPtr)
  440. INTEGER ErrorCode;
  441. Positions_tPosition Pos;
  442. INTEGER iClass;
  443. ADDRESS iPtr;
  444. # endif
  445. {
  446.   Errors_ErrorMessageI((LONGCARD)ErrorCode, (LONGCARD)Errors_Warning, Pos, (LONGCARD)iClass, iPtr);
  447. }
  448.  
  449. void Tree_InformationI
  450. # ifdef __STDC__
  451. (INTEGER ErrorCode, Positions_tPosition Pos, INTEGER iClass, ADDRESS iPtr)
  452. # else
  453. (ErrorCode, Pos, iClass, iPtr)
  454. INTEGER ErrorCode;
  455. Positions_tPosition Pos;
  456. INTEGER iClass;
  457. ADDRESS iPtr;
  458. # endif
  459. {
  460.   Errors_ErrorMessageI((LONGCARD)ErrorCode, (LONGCARD)Errors_Information, Pos, (LONGCARD)iClass, iPtr);
  461. }
  462.  
  463. void Tree_WI
  464. # ifdef __STDC__
  465. (Idents_tIdent i)
  466. # else
  467. (i)
  468. Idents_tIdent i;
  469. # endif
  470. {
  471.   Idents_WriteIdent(Tree_f, i);
  472. }
  473.  
  474. void Tree_WE
  475. # ifdef __STDC__
  476. (Idents_tIdent i)
  477. # else
  478. (i)
  479. Idents_tIdent i;
  480. # endif
  481. {
  482.   Strings_tString s;
  483.   CHAR Ch;
  484.   SHORTCARD j;
  485.  
  486.   Idents_GetString(i, &s);
  487.   {
  488.     SHORTCARD B_3 = 1, B_4 = Strings_Length(&s);
  489.  
  490.     if (B_3 <= B_4)
  491.       for (j = B_3;; j += 1) {
  492.         Ch = Strings_Char(&s, j);
  493.         if (Ch == '{' || Ch == '}' || Ch == '\\') {
  494.           IO_WriteC(Tree_f, '\\');
  495.         }
  496.         IO_WriteC(Tree_f, Ch);
  497.         if (j >= B_4) break;
  498.       }
  499.   }
  500. }
  501.  
  502. void Tree_WN
  503. # ifdef __STDC__
  504. (INTEGER n)
  505. # else
  506. (n)
  507. INTEGER n;
  508. # endif
  509. {
  510.   IO_WriteI(Tree_f, n, 0L);
  511. }
  512.  
  513. Tree_tTree Tree_yyAlloc
  514. # ifdef __STDC__
  515. ()
  516. # else
  517. ()
  518. # endif
  519. {
  520.   yytBlockPtr yyBlockPtr;
  521.  
  522.   yyBlockPtr = yyBlockList;
  523.   yyBlockList = (yytBlockPtr)Memory_Alloc((LONGINT)sizeof(yytBlock));
  524.   yyBlockList->yySuccessor = yyBlockPtr;
  525.   Tree_yyPoolFreePtr = ADR(yyBlockList->yyBlock);
  526.   Tree_yyPoolMaxPtr = (ADDRESS)(Tree_yyPoolFreePtr + yyBlockSize - yyMaxSize + 1);
  527.   INC1(Tree_HeapUsed, yyBlockSize);
  528.   return (Tree_tTree)Tree_yyPoolFreePtr;
  529. }
  530.  
  531. Tree_tTree Tree_MakeTree
  532. # ifdef __STDC__
  533. (SHORTCARD yyKind)
  534. # else
  535. (yyKind)
  536. SHORTCARD yyKind;
  537. # endif
  538. {
  539.   LONGINT yyByteCount;
  540.   Tree_tTree yyt;
  541.  
  542.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  543.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  544.     yyt = Tree_yyAlloc();
  545.   }
  546.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[yyKind]);
  547.   yyt->U_1.V_2.yyHead.yyMark = 0;
  548.   yyt->U_1.V_1.Kind = yyKind;
  549.   return yyt;
  550. }
  551.  
  552. BOOLEAN Tree_IsType
  553. # ifdef __STDC__
  554. (Tree_tTree yyTree, SHORTCARD yyKind)
  555. # else
  556. (yyTree, yyKind)
  557. Tree_tTree yyTree;
  558. SHORTCARD yyKind;
  559. # endif
  560. {
  561.   return yyTree != Tree_NoTree && yyKind <= yyTree->U_1.V_1.Kind && yyTree->U_1.V_1.Kind <= yyTypeRange.A[yyKind];
  562. }
  563.  
  564. Tree_tTree Tree_mClasses
  565. # ifdef __STDC__
  566. ()
  567. # else
  568. ()
  569. # endif
  570. {
  571.   LONGINT yyByteCount;
  572.   Tree_tTree yyt;
  573.  
  574.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  575.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  576.     yyt = Tree_yyAlloc();
  577.   }
  578.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Classes]);
  579.   yyt->U_1.V_2.yyHead.yyMark = 0;
  580.   yyt->U_1.V_1.Kind = Tree_Classes;
  581.   return yyt;
  582. }
  583.  
  584. Tree_tTree Tree_mNoClass
  585. # ifdef __STDC__
  586. ()
  587. # else
  588. ()
  589. # endif
  590. {
  591.   LONGINT yyByteCount;
  592.   Tree_tTree yyt;
  593.  
  594.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  595.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  596.     yyt = Tree_yyAlloc();
  597.   }
  598.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NoClass]);
  599.   yyt->U_1.V_2.yyHead.yyMark = 0;
  600.   yyt->U_1.V_1.Kind = Tree_NoClass;
  601.   return yyt;
  602. }
  603.  
  604. Tree_tTree Tree_mClass
  605. # ifdef __STDC__
  606. (Idents_tIdent pName, Tree_tClassProperties pProperties, Tree_tTree pAttributes, Tree_tTree pExtensions, Tree_tTree pNext)
  607. # else
  608. (pName, pProperties, pAttributes, pExtensions, pNext)
  609. Idents_tIdent pName;
  610. Tree_tClassProperties pProperties;
  611. Tree_tTree pAttributes;
  612. Tree_tTree pExtensions;
  613. Tree_tTree pNext;
  614. # endif
  615. {
  616.   LONGINT yyByteCount;
  617.   Tree_tTree yyt;
  618.  
  619.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  620.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  621.     yyt = Tree_yyAlloc();
  622.   }
  623.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Class]);
  624.   yyt->U_1.V_2.yyHead.yyMark = 0;
  625.   yyt->U_1.V_1.Kind = Tree_Class;
  626.   {
  627.     register Tree_yClass *W_1 = &yyt->U_1.V_5.Class;
  628.  
  629.     W_1->Name = pName;
  630.     W_1->Properties = pProperties;
  631.     W_1->Attributes = pAttributes;
  632.     W_1->Extensions = pExtensions;
  633.     W_1->Next = pNext;
  634.     W_1->BaseClass = Tree_NoTree;
  635.     W_1->Formals = Tree_NoTree;
  636.     W_1->TypeDesc = Tree_NoTree;
  637.   }
  638.   return yyt;
  639. }
  640.  
  641. Tree_tTree Tree_mAttributes
  642. # ifdef __STDC__
  643. ()
  644. # else
  645. ()
  646. # endif
  647. {
  648.   LONGINT yyByteCount;
  649.   Tree_tTree yyt;
  650.  
  651.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  652.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  653.     yyt = Tree_yyAlloc();
  654.   }
  655.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Attributes]);
  656.   yyt->U_1.V_2.yyHead.yyMark = 0;
  657.   yyt->U_1.V_1.Kind = Tree_Attributes;
  658.   return yyt;
  659. }
  660.  
  661. Tree_tTree Tree_mNoAttribute
  662. # ifdef __STDC__
  663. ()
  664. # else
  665. ()
  666. # endif
  667. {
  668.   LONGINT yyByteCount;
  669.   Tree_tTree yyt;
  670.  
  671.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  672.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  673.     yyt = Tree_yyAlloc();
  674.   }
  675.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NoAttribute]);
  676.   yyt->U_1.V_2.yyHead.yyMark = 0;
  677.   yyt->U_1.V_1.Kind = Tree_NoAttribute;
  678.   return yyt;
  679. }
  680.  
  681. Tree_tTree Tree_mAttrOrAction
  682. # ifdef __STDC__
  683. (Tree_tTree pNext)
  684. # else
  685. (pNext)
  686. Tree_tTree pNext;
  687. # endif
  688. {
  689.   LONGINT yyByteCount;
  690.   Tree_tTree yyt;
  691.  
  692.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  693.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  694.     yyt = Tree_yyAlloc();
  695.   }
  696.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_AttrOrAction]);
  697.   yyt->U_1.V_2.yyHead.yyMark = 0;
  698.   yyt->U_1.V_1.Kind = Tree_AttrOrAction;
  699.   {
  700.     register Tree_yAttrOrAction *W_2 = &yyt->U_1.V_8.AttrOrAction;
  701.  
  702.     W_2->Next = pNext;
  703.   }
  704.   return yyt;
  705. }
  706.  
  707. Tree_tTree Tree_mChild
  708. # ifdef __STDC__
  709. (Tree_tTree pNext, Idents_tIdent pName, Idents_tIdent pType, Tree_tAttrProperties pProperties)
  710. # else
  711. (pNext, pName, pType, pProperties)
  712. Tree_tTree pNext;
  713. Idents_tIdent pName;
  714. Idents_tIdent pType;
  715. Tree_tAttrProperties pProperties;
  716. # endif
  717. {
  718.   LONGINT yyByteCount;
  719.   Tree_tTree yyt;
  720.  
  721.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  722.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  723.     yyt = Tree_yyAlloc();
  724.   }
  725.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Child]);
  726.   yyt->U_1.V_2.yyHead.yyMark = 0;
  727.   yyt->U_1.V_1.Kind = Tree_Child;
  728.   {
  729.     register Tree_yChild *W_3 = &yyt->U_1.V_9.Child;
  730.  
  731.     W_3->Next = pNext;
  732.     W_3->Name = pName;
  733.     W_3->Type = pType;
  734.     W_3->Properties = pProperties;
  735.   }
  736.   return yyt;
  737. }
  738.  
  739. Tree_tTree Tree_mAttribute
  740. # ifdef __STDC__
  741. (Tree_tTree pNext, Idents_tIdent pName, Idents_tIdent pType, Tree_tAttrProperties pProperties)
  742. # else
  743. (pNext, pName, pType, pProperties)
  744. Tree_tTree pNext;
  745. Idents_tIdent pName;
  746. Idents_tIdent pType;
  747. Tree_tAttrProperties pProperties;
  748. # endif
  749. {
  750.   LONGINT yyByteCount;
  751.   Tree_tTree yyt;
  752.  
  753.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  754.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  755.     yyt = Tree_yyAlloc();
  756.   }
  757.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Attribute]);
  758.   yyt->U_1.V_2.yyHead.yyMark = 0;
  759.   yyt->U_1.V_1.Kind = Tree_Attribute;
  760.   {
  761.     register Tree_yAttribute *W_4 = &yyt->U_1.V_10.Attribute;
  762.  
  763.     W_4->Next = pNext;
  764.     W_4->Name = pName;
  765.     W_4->Type = pType;
  766.     W_4->Properties = pProperties;
  767.   }
  768.   return yyt;
  769. }
  770.  
  771. Tree_tTree Tree_mActionPart
  772. # ifdef __STDC__
  773. (Tree_tTree pNext)
  774. # else
  775. (pNext)
  776. Tree_tTree pNext;
  777. # endif
  778. {
  779.   LONGINT yyByteCount;
  780.   Tree_tTree yyt;
  781.  
  782.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  783.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  784.     yyt = Tree_yyAlloc();
  785.   }
  786.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_ActionPart]);
  787.   yyt->U_1.V_2.yyHead.yyMark = 0;
  788.   yyt->U_1.V_1.Kind = Tree_ActionPart;
  789.   {
  790.     register Tree_yActionPart *W_5 = &yyt->U_1.V_11.ActionPart;
  791.  
  792.     W_5->Next = pNext;
  793.   }
  794.   return yyt;
  795. }
  796.  
  797. Tree_tTree Tree_mCodes
  798. # ifdef __STDC__
  799. (Texts_tText pExport, Texts_tText pImport, Texts_tText pGlobal, Texts_tText pLocal, Texts_tText pBegin, Texts_tText pClose, Positions_tPosition pExportLine, Positions_tPosition pImportLine, Positions_tPosition pGlobalLine, Positions_tPosition pLocalLine, Positions_tPosition pBeginLine, Positions_tPosition pCloseLine)
  800. # else
  801. (pExport, pImport, pGlobal, pLocal, pBegin, pClose, pExportLine, pImportLine, pGlobalLine, pLocalLine, pBeginLine, pCloseLine)
  802. Texts_tText pExport;
  803. Texts_tText pImport;
  804. Texts_tText pGlobal;
  805. Texts_tText pLocal;
  806. Texts_tText pBegin;
  807. Texts_tText pClose;
  808. Positions_tPosition pExportLine;
  809. Positions_tPosition pImportLine;
  810. Positions_tPosition pGlobalLine;
  811. Positions_tPosition pLocalLine;
  812. Positions_tPosition pBeginLine;
  813. Positions_tPosition pCloseLine;
  814. # endif
  815. {
  816.   LONGINT yyByteCount;
  817.   Tree_tTree yyt;
  818.  
  819.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  820.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  821.     yyt = Tree_yyAlloc();
  822.   }
  823.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Codes]);
  824.   yyt->U_1.V_2.yyHead.yyMark = 0;
  825.   yyt->U_1.V_1.Kind = Tree_Codes;
  826.   {
  827.     register Tree_yCodes *W_6 = &yyt->U_1.V_12.Codes;
  828.  
  829.     W_6->Export = pExport;
  830.     W_6->Import = pImport;
  831.     W_6->Global = pGlobal;
  832.     W_6->Local = pLocal;
  833.     W_6->Begin = pBegin;
  834.     W_6->Close = pClose;
  835.     W_6->ExportLine = pExportLine;
  836.     W_6->ImportLine = pImportLine;
  837.     W_6->GlobalLine = pGlobalLine;
  838.     W_6->LocalLine = pLocalLine;
  839.     W_6->BeginLine = pBeginLine;
  840.     W_6->CloseLine = pCloseLine;
  841.   }
  842.   return yyt;
  843. }
  844.  
  845. Tree_tTree Tree_mDesignators
  846. # ifdef __STDC__
  847. ()
  848. # else
  849. ()
  850. # endif
  851. {
  852.   LONGINT yyByteCount;
  853.   Tree_tTree yyt;
  854.  
  855.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  856.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  857.     yyt = Tree_yyAlloc();
  858.   }
  859.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Designators]);
  860.   yyt->U_1.V_2.yyHead.yyMark = 0;
  861.   yyt->U_1.V_1.Kind = Tree_Designators;
  862.   return yyt;
  863. }
  864.  
  865. Tree_tTree Tree_mNoDesignator
  866. # ifdef __STDC__
  867. ()
  868. # else
  869. ()
  870. # endif
  871. {
  872.   LONGINT yyByteCount;
  873.   Tree_tTree yyt;
  874.  
  875.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  876.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  877.     yyt = Tree_yyAlloc();
  878.   }
  879.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NoDesignator]);
  880.   yyt->U_1.V_2.yyHead.yyMark = 0;
  881.   yyt->U_1.V_1.Kind = Tree_NoDesignator;
  882.   return yyt;
  883. }
  884.  
  885. Tree_tTree Tree_mDesignator
  886. # ifdef __STDC__
  887. (Idents_tIdent pSelector, Idents_tIdent pAttribute, Positions_tPosition pPos, Tree_tTree pNext)
  888. # else
  889. (pSelector, pAttribute, pPos, pNext)
  890. Idents_tIdent pSelector;
  891. Idents_tIdent pAttribute;
  892. Positions_tPosition pPos;
  893. Tree_tTree pNext;
  894. # endif
  895. {
  896.   LONGINT yyByteCount;
  897.   Tree_tTree yyt;
  898.  
  899.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  900.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  901.     yyt = Tree_yyAlloc();
  902.   }
  903.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Designator]);
  904.   yyt->U_1.V_2.yyHead.yyMark = 0;
  905.   yyt->U_1.V_1.Kind = Tree_Designator;
  906.   {
  907.     register Tree_yDesignator *W_7 = &yyt->U_1.V_15.Designator;
  908.  
  909.     W_7->Selector = pSelector;
  910.     W_7->Attribute = pAttribute;
  911.     W_7->Pos = pPos;
  912.     W_7->Next = pNext;
  913.     W_7->Type = Idents_NoIdent;
  914.   }
  915.   return yyt;
  916. }
  917.  
  918. Tree_tTree Tree_mIdent
  919. # ifdef __STDC__
  920. (Idents_tIdent pAttribute, Positions_tPosition pPos, Tree_tTree pNext)
  921. # else
  922. (pAttribute, pPos, pNext)
  923. Idents_tIdent pAttribute;
  924. Positions_tPosition pPos;
  925. Tree_tTree pNext;
  926. # endif
  927. {
  928.   LONGINT yyByteCount;
  929.   Tree_tTree yyt;
  930.  
  931.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  932.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  933.     yyt = Tree_yyAlloc();
  934.   }
  935.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Ident]);
  936.   yyt->U_1.V_2.yyHead.yyMark = 0;
  937.   yyt->U_1.V_1.Kind = Tree_Ident;
  938.   {
  939.     register Tree_yIdent *W_8 = &yyt->U_1.V_16.Ident;
  940.  
  941.     W_8->Attribute = pAttribute;
  942.     W_8->Pos = pPos;
  943.     W_8->Next = pNext;
  944.   }
  945.   return yyt;
  946. }
  947.  
  948. Tree_tTree Tree_mRemote
  949. # ifdef __STDC__
  950. (Tree_tTree pDesignators, Idents_tIdent pType, Idents_tIdent pAttribute, Positions_tPosition pPos, Tree_tTree pNext)
  951. # else
  952. (pDesignators, pType, pAttribute, pPos, pNext)
  953. Tree_tTree pDesignators;
  954. Idents_tIdent pType;
  955. Idents_tIdent pAttribute;
  956. Positions_tPosition pPos;
  957. Tree_tTree pNext;
  958. # endif
  959. {
  960.   LONGINT yyByteCount;
  961.   Tree_tTree yyt;
  962.  
  963.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  964.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  965.     yyt = Tree_yyAlloc();
  966.   }
  967.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Remote]);
  968.   yyt->U_1.V_2.yyHead.yyMark = 0;
  969.   yyt->U_1.V_1.Kind = Tree_Remote;
  970.   {
  971.     register Tree_yRemote *W_9 = &yyt->U_1.V_17.Remote;
  972.  
  973.     W_9->Designators = pDesignators;
  974.     W_9->Type = pType;
  975.     W_9->Attribute = pAttribute;
  976.     W_9->Pos = pPos;
  977.     W_9->Next = pNext;
  978.   }
  979.   return yyt;
  980. }
  981.  
  982. Tree_tTree Tree_mAny
  983. # ifdef __STDC__
  984. (StringMem_tStringRef pCode, Tree_tTree pNext)
  985. # else
  986. (pCode, pNext)
  987. StringMem_tStringRef pCode;
  988. Tree_tTree pNext;
  989. # endif
  990. {
  991.   LONGINT yyByteCount;
  992.   Tree_tTree yyt;
  993.  
  994.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  995.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  996.     yyt = Tree_yyAlloc();
  997.   }
  998.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Any]);
  999.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1000.   yyt->U_1.V_1.Kind = Tree_Any;
  1001.   {
  1002.     register Tree_yAny *W_10 = &yyt->U_1.V_18.Any;
  1003.  
  1004.     W_10->Code = pCode;
  1005.     W_10->Next = pNext;
  1006.   }
  1007.   return yyt;
  1008. }
  1009.  
  1010. Tree_tTree Tree_mAnys
  1011. # ifdef __STDC__
  1012. (Tree_tTree pLayouts, Tree_tTree pNext)
  1013. # else
  1014. (pLayouts, pNext)
  1015. Tree_tTree pLayouts;
  1016. Tree_tTree pNext;
  1017. # endif
  1018. {
  1019.   LONGINT yyByteCount;
  1020.   Tree_tTree yyt;
  1021.  
  1022.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1023.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1024.     yyt = Tree_yyAlloc();
  1025.   }
  1026.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Anys]);
  1027.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1028.   yyt->U_1.V_1.Kind = Tree_Anys;
  1029.   {
  1030.     register Tree_yAnys *W_11 = &yyt->U_1.V_19.Anys;
  1031.  
  1032.     W_11->Layouts = pLayouts;
  1033.     W_11->Next = pNext;
  1034.   }
  1035.   return yyt;
  1036. }
  1037.  
  1038. Tree_tTree Tree_mLayouts
  1039. # ifdef __STDC__
  1040. ()
  1041. # else
  1042. ()
  1043. # endif
  1044. {
  1045.   LONGINT yyByteCount;
  1046.   Tree_tTree yyt;
  1047.  
  1048.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1049.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1050.     yyt = Tree_yyAlloc();
  1051.   }
  1052.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Layouts]);
  1053.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1054.   yyt->U_1.V_1.Kind = Tree_Layouts;
  1055.   return yyt;
  1056. }
  1057.  
  1058. Tree_tTree Tree_mNoLayout
  1059. # ifdef __STDC__
  1060. ()
  1061. # else
  1062. ()
  1063. # endif
  1064. {
  1065.   LONGINT yyByteCount;
  1066.   Tree_tTree yyt;
  1067.  
  1068.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1069.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1070.     yyt = Tree_yyAlloc();
  1071.   }
  1072.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NoLayout]);
  1073.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1074.   yyt->U_1.V_1.Kind = Tree_NoLayout;
  1075.   return yyt;
  1076. }
  1077.  
  1078. Tree_tTree Tree_mLayoutAny
  1079. # ifdef __STDC__
  1080. (StringMem_tStringRef pCode, Tree_tTree pNext)
  1081. # else
  1082. (pCode, pNext)
  1083. StringMem_tStringRef pCode;
  1084. Tree_tTree pNext;
  1085. # endif
  1086. {
  1087.   LONGINT yyByteCount;
  1088.   Tree_tTree yyt;
  1089.  
  1090.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1091.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1092.     yyt = Tree_yyAlloc();
  1093.   }
  1094.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_LayoutAny]);
  1095.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1096.   yyt->U_1.V_1.Kind = Tree_LayoutAny;
  1097.   {
  1098.     register Tree_yLayoutAny *W_12 = &yyt->U_1.V_22.LayoutAny;
  1099.  
  1100.     W_12->Code = pCode;
  1101.     W_12->Next = pNext;
  1102.   }
  1103.   return yyt;
  1104. }
  1105.  
  1106. Tree_tTree Tree_mNames
  1107. # ifdef __STDC__
  1108. ()
  1109. # else
  1110. ()
  1111. # endif
  1112. {
  1113.   LONGINT yyByteCount;
  1114.   Tree_tTree yyt;
  1115.  
  1116.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1117.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1118.     yyt = Tree_yyAlloc();
  1119.   }
  1120.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Names]);
  1121.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1122.   yyt->U_1.V_1.Kind = Tree_Names;
  1123.   return yyt;
  1124. }
  1125.  
  1126. Tree_tTree Tree_mNoName
  1127. # ifdef __STDC__
  1128. ()
  1129. # else
  1130. ()
  1131. # endif
  1132. {
  1133.   LONGINT yyByteCount;
  1134.   Tree_tTree yyt;
  1135.  
  1136.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1137.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1138.     yyt = Tree_yyAlloc();
  1139.   }
  1140.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NoName]);
  1141.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1142.   yyt->U_1.V_1.Kind = Tree_NoName;
  1143.   return yyt;
  1144. }
  1145.  
  1146. Tree_tTree Tree_mName
  1147. # ifdef __STDC__
  1148. (Idents_tIdent pName, Positions_tPosition pPos, Tree_tTree pNext)
  1149. # else
  1150. (pName, pPos, pNext)
  1151. Idents_tIdent pName;
  1152. Positions_tPosition pPos;
  1153. Tree_tTree pNext;
  1154. # endif
  1155. {
  1156.   LONGINT yyByteCount;
  1157.   Tree_tTree yyt;
  1158.  
  1159.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1160.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1161.     yyt = Tree_yyAlloc();
  1162.   }
  1163.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Name]);
  1164.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1165.   yyt->U_1.V_1.Kind = Tree_Name;
  1166.   {
  1167.     register Tree_yName *W_13 = &yyt->U_1.V_25.Name;
  1168.  
  1169.     W_13->Name = pName;
  1170.     W_13->Pos = pPos;
  1171.     W_13->Next = pNext;
  1172.   }
  1173.   return yyt;
  1174. }
  1175.  
  1176. Tree_tTree Tree_mSpec
  1177. # ifdef __STDC__
  1178. (Idents_tIdent pTrafoName, Tree_tTree pTreeNames, Tree_tTree pPublic, Tree_tTree pExtern, Tree_tTree pCodes, Tree_tTree pRoutines)
  1179. # else
  1180. (pTrafoName, pTreeNames, pPublic, pExtern, pCodes, pRoutines)
  1181. Idents_tIdent pTrafoName;
  1182. Tree_tTree pTreeNames;
  1183. Tree_tTree pPublic;
  1184. Tree_tTree pExtern;
  1185. Tree_tTree pCodes;
  1186. Tree_tTree pRoutines;
  1187. # endif
  1188. {
  1189.   LONGINT yyByteCount;
  1190.   Tree_tTree yyt;
  1191.  
  1192.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1193.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1194.     yyt = Tree_yyAlloc();
  1195.   }
  1196.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Spec]);
  1197.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1198.   yyt->U_1.V_1.Kind = Tree_Spec;
  1199.   {
  1200.     register Tree_ySpec *W_14 = &yyt->U_1.V_26.Spec;
  1201.  
  1202.     W_14->TrafoName = pTrafoName;
  1203.     W_14->TreeNames = pTreeNames;
  1204.     W_14->Public = pPublic;
  1205.     W_14->Extern = pExtern;
  1206.     W_14->Codes = pCodes;
  1207.     W_14->Routines = pRoutines;
  1208.   }
  1209.   return yyt;
  1210. }
  1211.  
  1212. Tree_tTree Tree_mTreeNames
  1213. # ifdef __STDC__
  1214. ()
  1215. # else
  1216. ()
  1217. # endif
  1218. {
  1219.   LONGINT yyByteCount;
  1220.   Tree_tTree yyt;
  1221.  
  1222.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1223.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1224.     yyt = Tree_yyAlloc();
  1225.   }
  1226.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_TreeNames]);
  1227.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1228.   yyt->U_1.V_1.Kind = Tree_TreeNames;
  1229.   return yyt;
  1230. }
  1231.  
  1232. Tree_tTree Tree_mNoTreeName
  1233. # ifdef __STDC__
  1234. ()
  1235. # else
  1236. ()
  1237. # endif
  1238. {
  1239.   LONGINT yyByteCount;
  1240.   Tree_tTree yyt;
  1241.  
  1242.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1243.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1244.     yyt = Tree_yyAlloc();
  1245.   }
  1246.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NoTreeName]);
  1247.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1248.   yyt->U_1.V_1.Kind = Tree_NoTreeName;
  1249.   return yyt;
  1250. }
  1251.  
  1252. Tree_tTree Tree_mTreeName
  1253. # ifdef __STDC__
  1254. (Idents_tIdent pName, Positions_tPosition pPos, Tree_tTree pNext)
  1255. # else
  1256. (pName, pPos, pNext)
  1257. Idents_tIdent pName;
  1258. Positions_tPosition pPos;
  1259. Tree_tTree pNext;
  1260. # endif
  1261. {
  1262.   LONGINT yyByteCount;
  1263.   Tree_tTree yyt;
  1264.  
  1265.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1266.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1267.     yyt = Tree_yyAlloc();
  1268.   }
  1269.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_TreeName]);
  1270.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1271.   yyt->U_1.V_1.Kind = Tree_TreeName;
  1272.   {
  1273.     register Tree_yTreeName *W_15 = &yyt->U_1.V_29.TreeName;
  1274.  
  1275.     W_15->Name = pName;
  1276.     W_15->Pos = pPos;
  1277.     W_15->Next = pNext;
  1278.     W_15->Classes = Tree_NoTree;
  1279.   }
  1280.   return yyt;
  1281. }
  1282.  
  1283. Tree_tTree Tree_mRoutines
  1284. # ifdef __STDC__
  1285. ()
  1286. # else
  1287. ()
  1288. # endif
  1289. {
  1290.   LONGINT yyByteCount;
  1291.   Tree_tTree yyt;
  1292.  
  1293.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1294.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1295.     yyt = Tree_yyAlloc();
  1296.   }
  1297.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Routines]);
  1298.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1299.   yyt->U_1.V_1.Kind = Tree_Routines;
  1300.   return yyt;
  1301. }
  1302.  
  1303. Tree_tTree Tree_mNoRoutine
  1304. # ifdef __STDC__
  1305. ()
  1306. # else
  1307. ()
  1308. # endif
  1309. {
  1310.   LONGINT yyByteCount;
  1311.   Tree_tTree yyt;
  1312.  
  1313.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1314.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1315.     yyt = Tree_yyAlloc();
  1316.   }
  1317.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NoRoutine]);
  1318.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1319.   yyt->U_1.V_1.Kind = Tree_NoRoutine;
  1320.   return yyt;
  1321. }
  1322.  
  1323. Tree_tTree Tree_mRoutine
  1324. # ifdef __STDC__
  1325. (Tree_tTree pNext, Idents_tIdent pName, Positions_tPosition pPos, Tree_tTree pInParams, Tree_tTree pOutParams, Tree_tTree pExtern, Texts_tText pLocal, Positions_tPosition pLocalLine, Tree_tTree pRules)
  1326. # else
  1327. (pNext, pName, pPos, pInParams, pOutParams, pExtern, pLocal, pLocalLine, pRules)
  1328. Tree_tTree pNext;
  1329. Idents_tIdent pName;
  1330. Positions_tPosition pPos;
  1331. Tree_tTree pInParams;
  1332. Tree_tTree pOutParams;
  1333. Tree_tTree pExtern;
  1334. Texts_tText pLocal;
  1335. Positions_tPosition pLocalLine;
  1336. Tree_tTree pRules;
  1337. # endif
  1338. {
  1339.   LONGINT yyByteCount;
  1340.   Tree_tTree yyt;
  1341.  
  1342.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1343.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1344.     yyt = Tree_yyAlloc();
  1345.   }
  1346.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Routine]);
  1347.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1348.   yyt->U_1.V_1.Kind = Tree_Routine;
  1349.   {
  1350.     register Tree_yRoutine *W_16 = &yyt->U_1.V_32.Routine;
  1351.  
  1352.     W_16->Next = pNext;
  1353.     W_16->Name = pName;
  1354.     W_16->Pos = pPos;
  1355.     W_16->InParams = pInParams;
  1356.     W_16->OutParams = pOutParams;
  1357.     W_16->Extern = pExtern;
  1358.     W_16->Local = pLocal;
  1359.     W_16->LocalLine = pLocalLine;
  1360.     W_16->Rules = pRules;
  1361.     W_16->InForm = Tree_NoTree;
  1362.     W_16->OutForm = Tree_NoTree;
  1363.     W_16->ParamDecls = Tree_NoTree;
  1364.     W_16->IsExtern = FALSE;
  1365.     W_16->Decisions = Tree_NoTree;
  1366.   }
  1367.   return yyt;
  1368. }
  1369.  
  1370. Tree_tTree Tree_mProcedure
  1371. # ifdef __STDC__
  1372. (Tree_tTree pNext, Idents_tIdent pName, Positions_tPosition pPos, Tree_tTree pInParams, Tree_tTree pOutParams, Tree_tTree pExtern, Texts_tText pLocal, Positions_tPosition pLocalLine, Tree_tTree pRules)
  1373. # else
  1374. (pNext, pName, pPos, pInParams, pOutParams, pExtern, pLocal, pLocalLine, pRules)
  1375. Tree_tTree pNext;
  1376. Idents_tIdent pName;
  1377. Positions_tPosition pPos;
  1378. Tree_tTree pInParams;
  1379. Tree_tTree pOutParams;
  1380. Tree_tTree pExtern;
  1381. Texts_tText pLocal;
  1382. Positions_tPosition pLocalLine;
  1383. Tree_tTree pRules;
  1384. # endif
  1385. {
  1386.   LONGINT yyByteCount;
  1387.   Tree_tTree yyt;
  1388.  
  1389.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1390.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1391.     yyt = Tree_yyAlloc();
  1392.   }
  1393.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Procedure]);
  1394.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1395.   yyt->U_1.V_1.Kind = Tree_Procedure;
  1396.   {
  1397.     register Tree_yProcedure *W_17 = &yyt->U_1.V_33.Procedure;
  1398.  
  1399.     W_17->Next = pNext;
  1400.     W_17->Name = pName;
  1401.     W_17->Pos = pPos;
  1402.     W_17->InParams = pInParams;
  1403.     W_17->OutParams = pOutParams;
  1404.     W_17->Extern = pExtern;
  1405.     W_17->Local = pLocal;
  1406.     W_17->LocalLine = pLocalLine;
  1407.     W_17->Rules = pRules;
  1408.     W_17->InForm = Tree_NoTree;
  1409.     W_17->OutForm = Tree_NoTree;
  1410.     W_17->ParamDecls = Tree_NoTree;
  1411.     W_17->IsExtern = FALSE;
  1412.     W_17->Decisions = Tree_NoTree;
  1413.   }
  1414.   return yyt;
  1415. }
  1416.  
  1417. Tree_tTree Tree_mFunction
  1418. # ifdef __STDC__
  1419. (Tree_tTree pNext, Idents_tIdent pName, Positions_tPosition pPos, Tree_tTree pInParams, Tree_tTree pOutParams, Tree_tTree pExtern, Texts_tText pLocal, Positions_tPosition pLocalLine, Tree_tTree pRules, Tree_tTree pReturnParams)
  1420. # else
  1421. (pNext, pName, pPos, pInParams, pOutParams, pExtern, pLocal, pLocalLine, pRules, pReturnParams)
  1422. Tree_tTree pNext;
  1423. Idents_tIdent pName;
  1424. Positions_tPosition pPos;
  1425. Tree_tTree pInParams;
  1426. Tree_tTree pOutParams;
  1427. Tree_tTree pExtern;
  1428. Texts_tText pLocal;
  1429. Positions_tPosition pLocalLine;
  1430. Tree_tTree pRules;
  1431. Tree_tTree pReturnParams;
  1432. # endif
  1433. {
  1434.   LONGINT yyByteCount;
  1435.   Tree_tTree yyt;
  1436.  
  1437.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1438.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1439.     yyt = Tree_yyAlloc();
  1440.   }
  1441.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Function]);
  1442.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1443.   yyt->U_1.V_1.Kind = Tree_Function;
  1444.   {
  1445.     register Tree_yFunction *W_18 = &yyt->U_1.V_34.Function;
  1446.  
  1447.     W_18->Next = pNext;
  1448.     W_18->Name = pName;
  1449.     W_18->Pos = pPos;
  1450.     W_18->InParams = pInParams;
  1451.     W_18->OutParams = pOutParams;
  1452.     W_18->Extern = pExtern;
  1453.     W_18->Local = pLocal;
  1454.     W_18->LocalLine = pLocalLine;
  1455.     W_18->Rules = pRules;
  1456.     W_18->InForm = Tree_NoTree;
  1457.     W_18->OutForm = Tree_NoTree;
  1458.     W_18->ParamDecls = Tree_NoTree;
  1459.     W_18->IsExtern = FALSE;
  1460.     W_18->Decisions = Tree_NoTree;
  1461.     W_18->ReturnParams = pReturnParams;
  1462.     W_18->ReturnForm = Tree_NoTree;
  1463.   }
  1464.   return yyt;
  1465. }
  1466.  
  1467. Tree_tTree Tree_mPredicate
  1468. # ifdef __STDC__
  1469. (Tree_tTree pNext, Idents_tIdent pName, Positions_tPosition pPos, Tree_tTree pInParams, Tree_tTree pOutParams, Tree_tTree pExtern, Texts_tText pLocal, Positions_tPosition pLocalLine, Tree_tTree pRules)
  1470. # else
  1471. (pNext, pName, pPos, pInParams, pOutParams, pExtern, pLocal, pLocalLine, pRules)
  1472. Tree_tTree pNext;
  1473. Idents_tIdent pName;
  1474. Positions_tPosition pPos;
  1475. Tree_tTree pInParams;
  1476. Tree_tTree pOutParams;
  1477. Tree_tTree pExtern;
  1478. Texts_tText pLocal;
  1479. Positions_tPosition pLocalLine;
  1480. Tree_tTree pRules;
  1481. # endif
  1482. {
  1483.   LONGINT yyByteCount;
  1484.   Tree_tTree yyt;
  1485.  
  1486.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1487.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1488.     yyt = Tree_yyAlloc();
  1489.   }
  1490.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Predicate]);
  1491.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1492.   yyt->U_1.V_1.Kind = Tree_Predicate;
  1493.   {
  1494.     register Tree_yPredicate *W_19 = &yyt->U_1.V_35.Predicate;
  1495.  
  1496.     W_19->Next = pNext;
  1497.     W_19->Name = pName;
  1498.     W_19->Pos = pPos;
  1499.     W_19->InParams = pInParams;
  1500.     W_19->OutParams = pOutParams;
  1501.     W_19->Extern = pExtern;
  1502.     W_19->Local = pLocal;
  1503.     W_19->LocalLine = pLocalLine;
  1504.     W_19->Rules = pRules;
  1505.     W_19->InForm = Tree_NoTree;
  1506.     W_19->OutForm = Tree_NoTree;
  1507.     W_19->ParamDecls = Tree_NoTree;
  1508.     W_19->IsExtern = FALSE;
  1509.     W_19->Decisions = Tree_NoTree;
  1510.   }
  1511.   return yyt;
  1512. }
  1513.  
  1514. Tree_tTree Tree_mParameters
  1515. # ifdef __STDC__
  1516. ()
  1517. # else
  1518. ()
  1519. # endif
  1520. {
  1521.   LONGINT yyByteCount;
  1522.   Tree_tTree yyt;
  1523.  
  1524.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1525.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1526.     yyt = Tree_yyAlloc();
  1527.   }
  1528.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Parameters]);
  1529.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1530.   yyt->U_1.V_1.Kind = Tree_Parameters;
  1531.   return yyt;
  1532. }
  1533.  
  1534. Tree_tTree Tree_mNoParameter
  1535. # ifdef __STDC__
  1536. ()
  1537. # else
  1538. ()
  1539. # endif
  1540. {
  1541.   LONGINT yyByteCount;
  1542.   Tree_tTree yyt;
  1543.  
  1544.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1545.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1546.     yyt = Tree_yyAlloc();
  1547.   }
  1548.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NoParameter]);
  1549.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1550.   yyt->U_1.V_1.Kind = Tree_NoParameter;
  1551.   return yyt;
  1552. }
  1553.  
  1554. Tree_tTree Tree_mParam
  1555. # ifdef __STDC__
  1556. (BOOLEAN pIsRef, Idents_tIdent pName, Positions_tPosition pPos, Tree_tTree pType, Tree_tTree pNext)
  1557. # else
  1558. (pIsRef, pName, pPos, pType, pNext)
  1559. BOOLEAN pIsRef;
  1560. Idents_tIdent pName;
  1561. Positions_tPosition pPos;
  1562. Tree_tTree pType;
  1563. Tree_tTree pNext;
  1564. # endif
  1565. {
  1566.   LONGINT yyByteCount;
  1567.   Tree_tTree yyt;
  1568.  
  1569.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1570.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1571.     yyt = Tree_yyAlloc();
  1572.   }
  1573.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Param]);
  1574.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1575.   yyt->U_1.V_1.Kind = Tree_Param;
  1576.   {
  1577.     register Tree_yParam *W_20 = &yyt->U_1.V_38.Param;
  1578.  
  1579.     W_20->IsRef = pIsRef;
  1580.     W_20->Name = pName;
  1581.     W_20->Pos = pPos;
  1582.     W_20->Type = pType;
  1583.     W_20->Next = pNext;
  1584.   }
  1585.   return yyt;
  1586. }
  1587.  
  1588. Tree_tTree Tree_mType
  1589. # ifdef __STDC__
  1590. (Idents_tIdent pName, Positions_tPosition pPos, Tree_tTree pNames)
  1591. # else
  1592. (pName, pPos, pNames)
  1593. Idents_tIdent pName;
  1594. Positions_tPosition pPos;
  1595. Tree_tTree pNames;
  1596. # endif
  1597. {
  1598.   LONGINT yyByteCount;
  1599.   Tree_tTree yyt;
  1600.  
  1601.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1602.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1603.     yyt = Tree_yyAlloc();
  1604.   }
  1605.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Type]);
  1606.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1607.   yyt->U_1.V_1.Kind = Tree_Type;
  1608.   {
  1609.     register Tree_yType *W_21 = &yyt->U_1.V_39.Type;
  1610.  
  1611.     W_21->Name = pName;
  1612.     W_21->Pos = pPos;
  1613.     W_21->Names = pNames;
  1614.   }
  1615.   return yyt;
  1616. }
  1617.  
  1618. Tree_tTree Tree_mRules
  1619. # ifdef __STDC__
  1620. ()
  1621. # else
  1622. ()
  1623. # endif
  1624. {
  1625.   LONGINT yyByteCount;
  1626.   Tree_tTree yyt;
  1627.  
  1628.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1629.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1630.     yyt = Tree_yyAlloc();
  1631.   }
  1632.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Rules]);
  1633.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1634.   yyt->U_1.V_1.Kind = Tree_Rules;
  1635.   return yyt;
  1636. }
  1637.  
  1638. Tree_tTree Tree_mNoRule
  1639. # ifdef __STDC__
  1640. ()
  1641. # else
  1642. ()
  1643. # endif
  1644. {
  1645.   LONGINT yyByteCount;
  1646.   Tree_tTree yyt;
  1647.  
  1648.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1649.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1650.     yyt = Tree_yyAlloc();
  1651.   }
  1652.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NoRule]);
  1653.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1654.   yyt->U_1.V_1.Kind = Tree_NoRule;
  1655.   return yyt;
  1656. }
  1657.  
  1658. Tree_tTree Tree_mRule
  1659. # ifdef __STDC__
  1660. (Positions_tPosition pLine, Tree_tTree pPatterns, Tree_tTree pExprs, Tree_tTree pExpr, Tree_tTree pStatements, Tree_tTree pNext)
  1661. # else
  1662. (pLine, pPatterns, pExprs, pExpr, pStatements, pNext)
  1663. Positions_tPosition pLine;
  1664. Tree_tTree pPatterns;
  1665. Tree_tTree pExprs;
  1666. Tree_tTree pExpr;
  1667. Tree_tTree pStatements;
  1668. Tree_tTree pNext;
  1669. # endif
  1670. {
  1671.   LONGINT yyByteCount;
  1672.   Tree_tTree yyt;
  1673.  
  1674.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1675.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1676.     yyt = Tree_yyAlloc();
  1677.   }
  1678.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Rule]);
  1679.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1680.   yyt->U_1.V_1.Kind = Tree_Rule;
  1681.   {
  1682.     register Tree_yRule *W_22 = &yyt->U_1.V_42.Rule;
  1683.  
  1684.     W_22->Line = pLine;
  1685.     W_22->Patterns = pPatterns;
  1686.     W_22->Exprs = pExprs;
  1687.     W_22->Expr = pExpr;
  1688.     W_22->Statements = pStatements;
  1689.     W_22->Next = pNext;
  1690.     W_22->VarDecls = Tree_NoTree;
  1691.     W_22->HasTempos = FALSE;
  1692.     W_22->HasPatterns = FALSE;
  1693.     W_22->Tempo = Idents_NoIdent;
  1694.     W_22->Tests = Tree_NoTree;
  1695.     W_22->HasExit = FALSE;
  1696.     W_22->HasAssign = FALSE;
  1697.     W_22->HasTargetCode = FALSE;
  1698.     W_22->HasRejectOrFail = FALSE;
  1699.   }
  1700.   return yyt;
  1701. }
  1702.  
  1703. Tree_tTree Tree_mPatterns
  1704. # ifdef __STDC__
  1705. ()
  1706. # else
  1707. ()
  1708. # endif
  1709. {
  1710.   LONGINT yyByteCount;
  1711.   Tree_tTree yyt;
  1712.  
  1713.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1714.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1715.     yyt = Tree_yyAlloc();
  1716.   }
  1717.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Patterns]);
  1718.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1719.   yyt->U_1.V_1.Kind = Tree_Patterns;
  1720.   return yyt;
  1721. }
  1722.  
  1723. Tree_tTree Tree_mNoPattern
  1724. # ifdef __STDC__
  1725. (Positions_tPosition pPos)
  1726. # else
  1727. (pPos)
  1728. Positions_tPosition pPos;
  1729. # endif
  1730. {
  1731.   LONGINT yyByteCount;
  1732.   Tree_tTree yyt;
  1733.  
  1734.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1735.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1736.     yyt = Tree_yyAlloc();
  1737.   }
  1738.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NoPattern]);
  1739.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1740.   yyt->U_1.V_1.Kind = Tree_NoPattern;
  1741.   {
  1742.     register Tree_yNoPattern *W_23 = &yyt->U_1.V_44.NoPattern;
  1743.  
  1744.     W_23->Pos = pPos;
  1745.   }
  1746.   return yyt;
  1747. }
  1748.  
  1749. Tree_tTree Tree_mOnePattern
  1750. # ifdef __STDC__
  1751. (Tree_tTree pPattern, Tree_tTree pNext)
  1752. # else
  1753. (pPattern, pNext)
  1754. Tree_tTree pPattern;
  1755. Tree_tTree pNext;
  1756. # endif
  1757. {
  1758.   LONGINT yyByteCount;
  1759.   Tree_tTree yyt;
  1760.  
  1761.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1762.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1763.     yyt = Tree_yyAlloc();
  1764.   }
  1765.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_OnePattern]);
  1766.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1767.   yyt->U_1.V_1.Kind = Tree_OnePattern;
  1768.   {
  1769.     register Tree_yOnePattern *W_24 = &yyt->U_1.V_45.OnePattern;
  1770.  
  1771.     W_24->Pattern = pPattern;
  1772.     W_24->Next = pNext;
  1773.   }
  1774.   return yyt;
  1775. }
  1776.  
  1777. Tree_tTree Tree_mPatternsList
  1778. # ifdef __STDC__
  1779. ()
  1780. # else
  1781. ()
  1782. # endif
  1783. {
  1784.   LONGINT yyByteCount;
  1785.   Tree_tTree yyt;
  1786.  
  1787.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1788.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1789.     yyt = Tree_yyAlloc();
  1790.   }
  1791.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_PatternsList]);
  1792.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1793.   yyt->U_1.V_1.Kind = Tree_PatternsList;
  1794.   return yyt;
  1795. }
  1796.  
  1797. Tree_tTree Tree_mNoPatternsList
  1798. # ifdef __STDC__
  1799. ()
  1800. # else
  1801. ()
  1802. # endif
  1803. {
  1804.   LONGINT yyByteCount;
  1805.   Tree_tTree yyt;
  1806.  
  1807.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1808.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1809.     yyt = Tree_yyAlloc();
  1810.   }
  1811.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NoPatternsList]);
  1812.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1813.   yyt->U_1.V_1.Kind = Tree_NoPatternsList;
  1814.   return yyt;
  1815. }
  1816.  
  1817. Tree_tTree Tree_mOnePatternsList
  1818. # ifdef __STDC__
  1819. (Tree_tTree pPatterns, Tree_tTree pNext)
  1820. # else
  1821. (pPatterns, pNext)
  1822. Tree_tTree pPatterns;
  1823. Tree_tTree pNext;
  1824. # endif
  1825. {
  1826.   LONGINT yyByteCount;
  1827.   Tree_tTree yyt;
  1828.  
  1829.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1830.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1831.     yyt = Tree_yyAlloc();
  1832.   }
  1833.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_OnePatternsList]);
  1834.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1835.   yyt->U_1.V_1.Kind = Tree_OnePatternsList;
  1836.   {
  1837.     register Tree_yOnePatternsList *W_25 = &yyt->U_1.V_48.OnePatternsList;
  1838.  
  1839.     W_25->Patterns = pPatterns;
  1840.     W_25->Next = pNext;
  1841.   }
  1842.   return yyt;
  1843. }
  1844.  
  1845. Tree_tTree Tree_mPattern
  1846. # ifdef __STDC__
  1847. (Positions_tPosition pPos)
  1848. # else
  1849. (pPos)
  1850. Positions_tPosition pPos;
  1851. # endif
  1852. {
  1853.   LONGINT yyByteCount;
  1854.   Tree_tTree yyt;
  1855.  
  1856.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1857.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1858.     yyt = Tree_yyAlloc();
  1859.   }
  1860.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Pattern]);
  1861.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1862.   yyt->U_1.V_1.Kind = Tree_Pattern;
  1863.   {
  1864.     register Tree_yPattern *W_26 = &yyt->U_1.V_49.Pattern;
  1865.  
  1866.     W_26->Pos = pPos;
  1867.     W_26->Tempo = Idents_NoIdent;
  1868.     W_26->TypeDesc = Tree_NoTree;
  1869.     W_26->Path = Tree_NoTree;
  1870.   }
  1871.   return yyt;
  1872. }
  1873.  
  1874. Tree_tTree Tree_mDecompose
  1875. # ifdef __STDC__
  1876. (Positions_tPosition pPos, Idents_tIdent pSelector, Tree_tTree pExpr, Tree_tTree pPatterns, BOOLEAN pWiden)
  1877. # else
  1878. (pPos, pSelector, pExpr, pPatterns, pWiden)
  1879. Positions_tPosition pPos;
  1880. Idents_tIdent pSelector;
  1881. Tree_tTree pExpr;
  1882. Tree_tTree pPatterns;
  1883. BOOLEAN pWiden;
  1884. # endif
  1885. {
  1886.   LONGINT yyByteCount;
  1887.   Tree_tTree yyt;
  1888.  
  1889.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1890.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1891.     yyt = Tree_yyAlloc();
  1892.   }
  1893.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Decompose]);
  1894.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1895.   yyt->U_1.V_1.Kind = Tree_Decompose;
  1896.   {
  1897.     register Tree_yDecompose *W_27 = &yyt->U_1.V_50.Decompose;
  1898.  
  1899.     W_27->Pos = pPos;
  1900.     W_27->Tempo = Idents_NoIdent;
  1901.     W_27->TypeDesc = Tree_NoTree;
  1902.     W_27->Path = Tree_NoTree;
  1903.     W_27->Selector = pSelector;
  1904.     W_27->Expr = pExpr;
  1905.     W_27->Patterns = pPatterns;
  1906.     W_27->Widen = pWiden;
  1907.   }
  1908.   return yyt;
  1909. }
  1910.  
  1911. Tree_tTree Tree_mVarDef
  1912. # ifdef __STDC__
  1913. (Positions_tPosition pPos, Idents_tIdent pName)
  1914. # else
  1915. (pPos, pName)
  1916. Positions_tPosition pPos;
  1917. Idents_tIdent pName;
  1918. # endif
  1919. {
  1920.   LONGINT yyByteCount;
  1921.   Tree_tTree yyt;
  1922.  
  1923.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1924.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1925.     yyt = Tree_yyAlloc();
  1926.   }
  1927.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_VarDef]);
  1928.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1929.   yyt->U_1.V_1.Kind = Tree_VarDef;
  1930.   {
  1931.     register Tree_yVarDef *W_28 = &yyt->U_1.V_51.VarDef;
  1932.  
  1933.     W_28->Pos = pPos;
  1934.     W_28->Tempo = Idents_NoIdent;
  1935.     W_28->TypeDesc = Tree_NoTree;
  1936.     W_28->Path = Tree_NoTree;
  1937.     W_28->Name = pName;
  1938.   }
  1939.   return yyt;
  1940. }
  1941.  
  1942. Tree_tTree Tree_mNilTest
  1943. # ifdef __STDC__
  1944. (Positions_tPosition pPos, Idents_tIdent pSelector)
  1945. # else
  1946. (pPos, pSelector)
  1947. Positions_tPosition pPos;
  1948. Idents_tIdent pSelector;
  1949. # endif
  1950. {
  1951.   LONGINT yyByteCount;
  1952.   Tree_tTree yyt;
  1953.  
  1954.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1955.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1956.     yyt = Tree_yyAlloc();
  1957.   }
  1958.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NilTest]);
  1959.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1960.   yyt->U_1.V_1.Kind = Tree_NilTest;
  1961.   {
  1962.     register Tree_yNilTest *W_29 = &yyt->U_1.V_52.NilTest;
  1963.  
  1964.     W_29->Pos = pPos;
  1965.     W_29->Tempo = Idents_NoIdent;
  1966.     W_29->TypeDesc = Tree_NoTree;
  1967.     W_29->Path = Tree_NoTree;
  1968.     W_29->Selector = pSelector;
  1969.   }
  1970.   return yyt;
  1971. }
  1972.  
  1973. Tree_tTree Tree_mDontCare1
  1974. # ifdef __STDC__
  1975. (Positions_tPosition pPos)
  1976. # else
  1977. (pPos)
  1978. Positions_tPosition pPos;
  1979. # endif
  1980. {
  1981.   LONGINT yyByteCount;
  1982.   Tree_tTree yyt;
  1983.  
  1984.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  1985.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  1986.     yyt = Tree_yyAlloc();
  1987.   }
  1988.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_DontCare1]);
  1989.   yyt->U_1.V_2.yyHead.yyMark = 0;
  1990.   yyt->U_1.V_1.Kind = Tree_DontCare1;
  1991.   {
  1992.     register Tree_yDontCare1 *W_30 = &yyt->U_1.V_53.DontCare1;
  1993.  
  1994.     W_30->Pos = pPos;
  1995.     W_30->Tempo = Idents_NoIdent;
  1996.     W_30->TypeDesc = Tree_NoTree;
  1997.     W_30->Path = Tree_NoTree;
  1998.   }
  1999.   return yyt;
  2000. }
  2001.  
  2002. Tree_tTree Tree_mDontCare
  2003. # ifdef __STDC__
  2004. (Positions_tPosition pPos)
  2005. # else
  2006. (pPos)
  2007. Positions_tPosition pPos;
  2008. # endif
  2009. {
  2010.   LONGINT yyByteCount;
  2011.   Tree_tTree yyt;
  2012.  
  2013.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2014.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2015.     yyt = Tree_yyAlloc();
  2016.   }
  2017.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_DontCare]);
  2018.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2019.   yyt->U_1.V_1.Kind = Tree_DontCare;
  2020.   {
  2021.     register Tree_yDontCare *W_31 = &yyt->U_1.V_54.DontCare;
  2022.  
  2023.     W_31->Pos = pPos;
  2024.     W_31->Tempo = Idents_NoIdent;
  2025.     W_31->TypeDesc = Tree_NoTree;
  2026.     W_31->Path = Tree_NoTree;
  2027.     W_31->Tempos = Tree_NoTree;
  2028.   }
  2029.   return yyt;
  2030. }
  2031.  
  2032. Tree_tTree Tree_mValue
  2033. # ifdef __STDC__
  2034. (Positions_tPosition pPos, Tree_tTree pExpr)
  2035. # else
  2036. (pPos, pExpr)
  2037. Positions_tPosition pPos;
  2038. Tree_tTree pExpr;
  2039. # endif
  2040. {
  2041.   LONGINT yyByteCount;
  2042.   Tree_tTree yyt;
  2043.  
  2044.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2045.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2046.     yyt = Tree_yyAlloc();
  2047.   }
  2048.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Value]);
  2049.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2050.   yyt->U_1.V_1.Kind = Tree_Value;
  2051.   {
  2052.     register Tree_yValue *W_32 = &yyt->U_1.V_55.Value;
  2053.  
  2054.     W_32->Pos = pPos;
  2055.     W_32->Tempo = Idents_NoIdent;
  2056.     W_32->TypeDesc = Tree_NoTree;
  2057.     W_32->Path = Tree_NoTree;
  2058.     W_32->Expr = pExpr;
  2059.   }
  2060.   return yyt;
  2061. }
  2062.  
  2063. Tree_tTree Tree_mExprs
  2064. # ifdef __STDC__
  2065. ()
  2066. # else
  2067. ()
  2068. # endif
  2069. {
  2070.   LONGINT yyByteCount;
  2071.   Tree_tTree yyt;
  2072.  
  2073.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2074.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2075.     yyt = Tree_yyAlloc();
  2076.   }
  2077.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Exprs]);
  2078.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2079.   yyt->U_1.V_1.Kind = Tree_Exprs;
  2080.   return yyt;
  2081. }
  2082.  
  2083. Tree_tTree Tree_mNoExpr
  2084. # ifdef __STDC__
  2085. (Positions_tPosition pPos)
  2086. # else
  2087. (pPos)
  2088. Positions_tPosition pPos;
  2089. # endif
  2090. {
  2091.   LONGINT yyByteCount;
  2092.   Tree_tTree yyt;
  2093.  
  2094.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2095.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2096.     yyt = Tree_yyAlloc();
  2097.   }
  2098.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NoExpr]);
  2099.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2100.   yyt->U_1.V_1.Kind = Tree_NoExpr;
  2101.   {
  2102.     register Tree_yNoExpr *W_33 = &yyt->U_1.V_57.NoExpr;
  2103.  
  2104.     W_33->Pos = pPos;
  2105.   }
  2106.   return yyt;
  2107. }
  2108.  
  2109. Tree_tTree Tree_mOneExpr
  2110. # ifdef __STDC__
  2111. (Tree_tTree pExpr, Tree_tTree pNext)
  2112. # else
  2113. (pExpr, pNext)
  2114. Tree_tTree pExpr;
  2115. Tree_tTree pNext;
  2116. # endif
  2117. {
  2118.   LONGINT yyByteCount;
  2119.   Tree_tTree yyt;
  2120.  
  2121.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2122.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2123.     yyt = Tree_yyAlloc();
  2124.   }
  2125.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_OneExpr]);
  2126.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2127.   yyt->U_1.V_1.Kind = Tree_OneExpr;
  2128.   {
  2129.     register Tree_yOneExpr *W_34 = &yyt->U_1.V_58.OneExpr;
  2130.  
  2131.     W_34->Expr = pExpr;
  2132.     W_34->Next = pNext;
  2133.   }
  2134.   return yyt;
  2135. }
  2136.  
  2137. Tree_tTree Tree_mNamedExpr
  2138. # ifdef __STDC__
  2139. (Tree_tTree pExpr, Tree_tTree pNext, Idents_tIdent pName)
  2140. # else
  2141. (pExpr, pNext, pName)
  2142. Tree_tTree pExpr;
  2143. Tree_tTree pNext;
  2144. Idents_tIdent pName;
  2145. # endif
  2146. {
  2147.   LONGINT yyByteCount;
  2148.   Tree_tTree yyt;
  2149.  
  2150.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2151.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2152.     yyt = Tree_yyAlloc();
  2153.   }
  2154.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NamedExpr]);
  2155.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2156.   yyt->U_1.V_1.Kind = Tree_NamedExpr;
  2157.   {
  2158.     register Tree_yNamedExpr *W_35 = &yyt->U_1.V_59.NamedExpr;
  2159.  
  2160.     W_35->Expr = pExpr;
  2161.     W_35->Next = pNext;
  2162.     W_35->Name = pName;
  2163.   }
  2164.   return yyt;
  2165. }
  2166.  
  2167. Tree_tTree Tree_mExpr
  2168. # ifdef __STDC__
  2169. (Positions_tPosition pPos)
  2170. # else
  2171. (pPos)
  2172. Positions_tPosition pPos;
  2173. # endif
  2174. {
  2175.   LONGINT yyByteCount;
  2176.   Tree_tTree yyt;
  2177.  
  2178.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2179.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2180.     yyt = Tree_yyAlloc();
  2181.   }
  2182.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Expr]);
  2183.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2184.   yyt->U_1.V_1.Kind = Tree_Expr;
  2185.   {
  2186.     register Tree_yExpr *W_36 = &yyt->U_1.V_60.Expr;
  2187.  
  2188.     W_36->Pos = pPos;
  2189.   }
  2190.   return yyt;
  2191. }
  2192.  
  2193. Tree_tTree Tree_mCompose
  2194. # ifdef __STDC__
  2195. (Positions_tPosition pPos, Idents_tIdent pSelector, Tree_tTree pExpr, Tree_tTree pExprs, BOOLEAN pWiden)
  2196. # else
  2197. (pPos, pSelector, pExpr, pExprs, pWiden)
  2198. Positions_tPosition pPos;
  2199. Idents_tIdent pSelector;
  2200. Tree_tTree pExpr;
  2201. Tree_tTree pExprs;
  2202. BOOLEAN pWiden;
  2203. # endif
  2204. {
  2205.   LONGINT yyByteCount;
  2206.   Tree_tTree yyt;
  2207.  
  2208.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2209.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2210.     yyt = Tree_yyAlloc();
  2211.   }
  2212.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Compose]);
  2213.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2214.   yyt->U_1.V_1.Kind = Tree_Compose;
  2215.   {
  2216.     register Tree_yCompose *W_37 = &yyt->U_1.V_61.Compose;
  2217.  
  2218.     W_37->Pos = pPos;
  2219.     W_37->Selector = pSelector;
  2220.     W_37->Expr = pExpr;
  2221.     W_37->Exprs = pExprs;
  2222.     W_37->Widen = pWiden;
  2223.     W_37->Tempo = Idents_NoIdent;
  2224.     W_37->TypeDesc = Tree_NoTree;
  2225.   }
  2226.   return yyt;
  2227. }
  2228.  
  2229. Tree_tTree Tree_mVarUse
  2230. # ifdef __STDC__
  2231. (Positions_tPosition pPos, Idents_tIdent pName)
  2232. # else
  2233. (pPos, pName)
  2234. Positions_tPosition pPos;
  2235. Idents_tIdent pName;
  2236. # endif
  2237. {
  2238.   LONGINT yyByteCount;
  2239.   Tree_tTree yyt;
  2240.  
  2241.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2242.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2243.     yyt = Tree_yyAlloc();
  2244.   }
  2245.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_VarUse]);
  2246.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2247.   yyt->U_1.V_1.Kind = Tree_VarUse;
  2248.   {
  2249.     register Tree_yVarUse *W_38 = &yyt->U_1.V_62.VarUse;
  2250.  
  2251.     W_38->Pos = pPos;
  2252.     W_38->Name = pName;
  2253.   }
  2254.   return yyt;
  2255. }
  2256.  
  2257. Tree_tTree Tree_mAttrDesc
  2258. # ifdef __STDC__
  2259. (Positions_tPosition pPos, Idents_tIdent pName, Idents_tIdent pAttribute)
  2260. # else
  2261. (pPos, pName, pAttribute)
  2262. Positions_tPosition pPos;
  2263. Idents_tIdent pName;
  2264. Idents_tIdent pAttribute;
  2265. # endif
  2266. {
  2267.   LONGINT yyByteCount;
  2268.   Tree_tTree yyt;
  2269.  
  2270.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2271.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2272.     yyt = Tree_yyAlloc();
  2273.   }
  2274.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_AttrDesc]);
  2275.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2276.   yyt->U_1.V_1.Kind = Tree_AttrDesc;
  2277.   {
  2278.     register Tree_yAttrDesc *W_39 = &yyt->U_1.V_63.AttrDesc;
  2279.  
  2280.     W_39->Pos = pPos;
  2281.     W_39->Name = pName;
  2282.     W_39->Attribute = pAttribute;
  2283.     W_39->Type = Idents_NoIdent;
  2284.   }
  2285.   return yyt;
  2286. }
  2287.  
  2288. Tree_tTree Tree_mNil
  2289. # ifdef __STDC__
  2290. (Positions_tPosition pPos, Idents_tIdent pSelector)
  2291. # else
  2292. (pPos, pSelector)
  2293. Positions_tPosition pPos;
  2294. Idents_tIdent pSelector;
  2295. # endif
  2296. {
  2297.   LONGINT yyByteCount;
  2298.   Tree_tTree yyt;
  2299.  
  2300.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2301.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2302.     yyt = Tree_yyAlloc();
  2303.   }
  2304.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Nil]);
  2305.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2306.   yyt->U_1.V_1.Kind = Tree_Nil;
  2307.   {
  2308.     register Tree_yNil *W_40 = &yyt->U_1.V_64.Nil;
  2309.  
  2310.     W_40->Pos = pPos;
  2311.     W_40->Selector = pSelector;
  2312.   }
  2313.   return yyt;
  2314. }
  2315.  
  2316. Tree_tTree Tree_mCall
  2317. # ifdef __STDC__
  2318. (Positions_tPosition pPos, Tree_tTree pExpr, Tree_tTree pExprs, Tree_tTree pPatterns)
  2319. # else
  2320. (pPos, pExpr, pExprs, pPatterns)
  2321. Positions_tPosition pPos;
  2322. Tree_tTree pExpr;
  2323. Tree_tTree pExprs;
  2324. Tree_tTree pPatterns;
  2325. # endif
  2326. {
  2327.   LONGINT yyByteCount;
  2328.   Tree_tTree yyt;
  2329.  
  2330.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2331.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2332.     yyt = Tree_yyAlloc();
  2333.   }
  2334.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Call]);
  2335.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2336.   yyt->U_1.V_1.Kind = Tree_Call;
  2337.   {
  2338.     register Tree_yCall *W_41 = &yyt->U_1.V_65.Call;
  2339.  
  2340.     W_41->Pos = pPos;
  2341.     W_41->Expr = pExpr;
  2342.     W_41->Exprs = pExprs;
  2343.     W_41->Patterns = pPatterns;
  2344.   }
  2345.   return yyt;
  2346. }
  2347.  
  2348. Tree_tTree Tree_mBinary
  2349. # ifdef __STDC__
  2350. (Positions_tPosition pPos, Tree_tTree pLop, Idents_tIdent pOperator, Tree_tTree pRop)
  2351. # else
  2352. (pPos, pLop, pOperator, pRop)
  2353. Positions_tPosition pPos;
  2354. Tree_tTree pLop;
  2355. Idents_tIdent pOperator;
  2356. Tree_tTree pRop;
  2357. # endif
  2358. {
  2359.   LONGINT yyByteCount;
  2360.   Tree_tTree yyt;
  2361.  
  2362.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2363.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2364.     yyt = Tree_yyAlloc();
  2365.   }
  2366.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Binary]);
  2367.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2368.   yyt->U_1.V_1.Kind = Tree_Binary;
  2369.   {
  2370.     register Tree_yBinary *W_42 = &yyt->U_1.V_66.Binary;
  2371.  
  2372.     W_42->Pos = pPos;
  2373.     W_42->Lop = pLop;
  2374.     W_42->Operator = pOperator;
  2375.     W_42->Rop = pRop;
  2376.   }
  2377.   return yyt;
  2378. }
  2379.  
  2380. Tree_tTree Tree_mPreOperator
  2381. # ifdef __STDC__
  2382. (Positions_tPosition pPos, Idents_tIdent pOperator, Tree_tTree pExpr)
  2383. # else
  2384. (pPos, pOperator, pExpr)
  2385. Positions_tPosition pPos;
  2386. Idents_tIdent pOperator;
  2387. Tree_tTree pExpr;
  2388. # endif
  2389. {
  2390.   LONGINT yyByteCount;
  2391.   Tree_tTree yyt;
  2392.  
  2393.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2394.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2395.     yyt = Tree_yyAlloc();
  2396.   }
  2397.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_PreOperator]);
  2398.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2399.   yyt->U_1.V_1.Kind = Tree_PreOperator;
  2400.   {
  2401.     register Tree_yPreOperator *W_43 = &yyt->U_1.V_67.PreOperator;
  2402.  
  2403.     W_43->Pos = pPos;
  2404.     W_43->Operator = pOperator;
  2405.     W_43->Expr = pExpr;
  2406.   }
  2407.   return yyt;
  2408. }
  2409.  
  2410. Tree_tTree Tree_mPostOperator
  2411. # ifdef __STDC__
  2412. (Positions_tPosition pPos, Idents_tIdent pOperator, Tree_tTree pExpr)
  2413. # else
  2414. (pPos, pOperator, pExpr)
  2415. Positions_tPosition pPos;
  2416. Idents_tIdent pOperator;
  2417. Tree_tTree pExpr;
  2418. # endif
  2419. {
  2420.   LONGINT yyByteCount;
  2421.   Tree_tTree yyt;
  2422.  
  2423.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2424.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2425.     yyt = Tree_yyAlloc();
  2426.   }
  2427.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_PostOperator]);
  2428.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2429.   yyt->U_1.V_1.Kind = Tree_PostOperator;
  2430.   {
  2431.     register Tree_yPostOperator *W_44 = &yyt->U_1.V_68.PostOperator;
  2432.  
  2433.     W_44->Pos = pPos;
  2434.     W_44->Operator = pOperator;
  2435.     W_44->Expr = pExpr;
  2436.   }
  2437.   return yyt;
  2438. }
  2439.  
  2440. Tree_tTree Tree_mIndex
  2441. # ifdef __STDC__
  2442. (Positions_tPosition pPos, Tree_tTree pExpr, Tree_tTree pExprs)
  2443. # else
  2444. (pPos, pExpr, pExprs)
  2445. Positions_tPosition pPos;
  2446. Tree_tTree pExpr;
  2447. Tree_tTree pExprs;
  2448. # endif
  2449. {
  2450.   LONGINT yyByteCount;
  2451.   Tree_tTree yyt;
  2452.  
  2453.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2454.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2455.     yyt = Tree_yyAlloc();
  2456.   }
  2457.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Index]);
  2458.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2459.   yyt->U_1.V_1.Kind = Tree_Index;
  2460.   {
  2461.     register Tree_yIndex *W_45 = &yyt->U_1.V_69.Index;
  2462.  
  2463.     W_45->Pos = pPos;
  2464.     W_45->Expr = pExpr;
  2465.     W_45->Exprs = pExprs;
  2466.   }
  2467.   return yyt;
  2468. }
  2469.  
  2470. Tree_tTree Tree_mParents
  2471. # ifdef __STDC__
  2472. (Positions_tPosition pPos, Tree_tTree pExpr)
  2473. # else
  2474. (pPos, pExpr)
  2475. Positions_tPosition pPos;
  2476. Tree_tTree pExpr;
  2477. # endif
  2478. {
  2479.   LONGINT yyByteCount;
  2480.   Tree_tTree yyt;
  2481.  
  2482.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2483.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2484.     yyt = Tree_yyAlloc();
  2485.   }
  2486.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Parents]);
  2487.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2488.   yyt->U_1.V_1.Kind = Tree_Parents;
  2489.   {
  2490.     register Tree_yParents *W_46 = &yyt->U_1.V_70.Parents;
  2491.  
  2492.     W_46->Pos = pPos;
  2493.     W_46->Expr = pExpr;
  2494.   }
  2495.   return yyt;
  2496. }
  2497.  
  2498. Tree_tTree Tree_mTargetExpr
  2499. # ifdef __STDC__
  2500. (Positions_tPosition pPos, Tree_tTree pExpr)
  2501. # else
  2502. (pPos, pExpr)
  2503. Positions_tPosition pPos;
  2504. Tree_tTree pExpr;
  2505. # endif
  2506. {
  2507.   LONGINT yyByteCount;
  2508.   Tree_tTree yyt;
  2509.  
  2510.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2511.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2512.     yyt = Tree_yyAlloc();
  2513.   }
  2514.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_TargetExpr]);
  2515.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2516.   yyt->U_1.V_1.Kind = Tree_TargetExpr;
  2517.   {
  2518.     register Tree_yTargetExpr *W_47 = &yyt->U_1.V_71.TargetExpr;
  2519.  
  2520.     W_47->Pos = pPos;
  2521.     W_47->Expr = pExpr;
  2522.   }
  2523.   return yyt;
  2524. }
  2525.  
  2526. Tree_tTree Tree_mStringExpr
  2527. # ifdef __STDC__
  2528. (Positions_tPosition pPos, StringMem_tStringRef pString)
  2529. # else
  2530. (pPos, pString)
  2531. Positions_tPosition pPos;
  2532. StringMem_tStringRef pString;
  2533. # endif
  2534. {
  2535.   LONGINT yyByteCount;
  2536.   Tree_tTree yyt;
  2537.  
  2538.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2539.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2540.     yyt = Tree_yyAlloc();
  2541.   }
  2542.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_StringExpr]);
  2543.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2544.   yyt->U_1.V_1.Kind = Tree_StringExpr;
  2545.   {
  2546.     register Tree_yStringExpr *W_48 = &yyt->U_1.V_72.StringExpr;
  2547.  
  2548.     W_48->Pos = pPos;
  2549.     W_48->String = pString;
  2550.   }
  2551.   return yyt;
  2552. }
  2553.  
  2554. Tree_tTree Tree_mStatements
  2555. # ifdef __STDC__
  2556. ()
  2557. # else
  2558. ()
  2559. # endif
  2560. {
  2561.   LONGINT yyByteCount;
  2562.   Tree_tTree yyt;
  2563.  
  2564.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2565.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2566.     yyt = Tree_yyAlloc();
  2567.   }
  2568.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Statements]);
  2569.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2570.   yyt->U_1.V_1.Kind = Tree_Statements;
  2571.   return yyt;
  2572. }
  2573.  
  2574. Tree_tTree Tree_mNoStatement
  2575. # ifdef __STDC__
  2576. ()
  2577. # else
  2578. ()
  2579. # endif
  2580. {
  2581.   LONGINT yyByteCount;
  2582.   Tree_tTree yyt;
  2583.  
  2584.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2585.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2586.     yyt = Tree_yyAlloc();
  2587.   }
  2588.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NoStatement]);
  2589.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2590.   yyt->U_1.V_1.Kind = Tree_NoStatement;
  2591.   return yyt;
  2592. }
  2593.  
  2594. Tree_tTree Tree_mStatement
  2595. # ifdef __STDC__
  2596. (Positions_tPosition pPos, Tree_tTree pNext)
  2597. # else
  2598. (pPos, pNext)
  2599. Positions_tPosition pPos;
  2600. Tree_tTree pNext;
  2601. # endif
  2602. {
  2603.   LONGINT yyByteCount;
  2604.   Tree_tTree yyt;
  2605.  
  2606.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2607.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2608.     yyt = Tree_yyAlloc();
  2609.   }
  2610.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Statement]);
  2611.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2612.   yyt->U_1.V_1.Kind = Tree_Statement;
  2613.   {
  2614.     register Tree_yStatement *W_49 = &yyt->U_1.V_75.Statement;
  2615.  
  2616.     W_49->Pos = pPos;
  2617.     W_49->Next = pNext;
  2618.   }
  2619.   return yyt;
  2620. }
  2621.  
  2622. Tree_tTree Tree_mProcCall
  2623. # ifdef __STDC__
  2624. (Positions_tPosition pPos, Tree_tTree pNext, Tree_tTree pCall)
  2625. # else
  2626. (pPos, pNext, pCall)
  2627. Positions_tPosition pPos;
  2628. Tree_tTree pNext;
  2629. Tree_tTree pCall;
  2630. # endif
  2631. {
  2632.   LONGINT yyByteCount;
  2633.   Tree_tTree yyt;
  2634.  
  2635.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2636.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2637.     yyt = Tree_yyAlloc();
  2638.   }
  2639.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_ProcCall]);
  2640.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2641.   yyt->U_1.V_1.Kind = Tree_ProcCall;
  2642.   {
  2643.     register Tree_yProcCall *W_50 = &yyt->U_1.V_76.ProcCall;
  2644.  
  2645.     W_50->Pos = pPos;
  2646.     W_50->Next = pNext;
  2647.     W_50->Call = pCall;
  2648.   }
  2649.   return yyt;
  2650. }
  2651.  
  2652. Tree_tTree Tree_mCondition
  2653. # ifdef __STDC__
  2654. (Positions_tPosition pPos, Tree_tTree pNext, Tree_tTree pExpr)
  2655. # else
  2656. (pPos, pNext, pExpr)
  2657. Positions_tPosition pPos;
  2658. Tree_tTree pNext;
  2659. Tree_tTree pExpr;
  2660. # endif
  2661. {
  2662.   LONGINT yyByteCount;
  2663.   Tree_tTree yyt;
  2664.  
  2665.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2666.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2667.     yyt = Tree_yyAlloc();
  2668.   }
  2669.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Condition]);
  2670.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2671.   yyt->U_1.V_1.Kind = Tree_Condition;
  2672.   {
  2673.     register Tree_yCondition *W_51 = &yyt->U_1.V_77.Condition;
  2674.  
  2675.     W_51->Pos = pPos;
  2676.     W_51->Next = pNext;
  2677.     W_51->Expr = pExpr;
  2678.   }
  2679.   return yyt;
  2680. }
  2681.  
  2682. Tree_tTree Tree_mAssignment
  2683. # ifdef __STDC__
  2684. (Positions_tPosition pPos, Tree_tTree pNext, Tree_tTree pAdr, Tree_tTree pExpr)
  2685. # else
  2686. (pPos, pNext, pAdr, pExpr)
  2687. Positions_tPosition pPos;
  2688. Tree_tTree pNext;
  2689. Tree_tTree pAdr;
  2690. Tree_tTree pExpr;
  2691. # endif
  2692. {
  2693.   LONGINT yyByteCount;
  2694.   Tree_tTree yyt;
  2695.  
  2696.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2697.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2698.     yyt = Tree_yyAlloc();
  2699.   }
  2700.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Assignment]);
  2701.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2702.   yyt->U_1.V_1.Kind = Tree_Assignment;
  2703.   {
  2704.     register Tree_yAssignment *W_52 = &yyt->U_1.V_78.Assignment;
  2705.  
  2706.     W_52->Pos = pPos;
  2707.     W_52->Next = pNext;
  2708.     W_52->Adr = pAdr;
  2709.     W_52->Expr = pExpr;
  2710.   }
  2711.   return yyt;
  2712. }
  2713.  
  2714. Tree_tTree Tree_mReject
  2715. # ifdef __STDC__
  2716. (Positions_tPosition pPos, Tree_tTree pNext)
  2717. # else
  2718. (pPos, pNext)
  2719. Positions_tPosition pPos;
  2720. Tree_tTree pNext;
  2721. # endif
  2722. {
  2723.   LONGINT yyByteCount;
  2724.   Tree_tTree yyt;
  2725.  
  2726.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2727.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2728.     yyt = Tree_yyAlloc();
  2729.   }
  2730.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Reject]);
  2731.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2732.   yyt->U_1.V_1.Kind = Tree_Reject;
  2733.   {
  2734.     register Tree_yReject *W_53 = &yyt->U_1.V_79.Reject;
  2735.  
  2736.     W_53->Pos = pPos;
  2737.     W_53->Next = pNext;
  2738.   }
  2739.   return yyt;
  2740. }
  2741.  
  2742. Tree_tTree Tree_mFail
  2743. # ifdef __STDC__
  2744. (Positions_tPosition pPos, Tree_tTree pNext)
  2745. # else
  2746. (pPos, pNext)
  2747. Positions_tPosition pPos;
  2748. Tree_tTree pNext;
  2749. # endif
  2750. {
  2751.   LONGINT yyByteCount;
  2752.   Tree_tTree yyt;
  2753.  
  2754.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2755.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2756.     yyt = Tree_yyAlloc();
  2757.   }
  2758.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Fail]);
  2759.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2760.   yyt->U_1.V_1.Kind = Tree_Fail;
  2761.   {
  2762.     register Tree_yFail *W_54 = &yyt->U_1.V_80.Fail;
  2763.  
  2764.     W_54->Pos = pPos;
  2765.     W_54->Next = pNext;
  2766.   }
  2767.   return yyt;
  2768. }
  2769.  
  2770. Tree_tTree Tree_mTargetStmt
  2771. # ifdef __STDC__
  2772. (Positions_tPosition pPos, Tree_tTree pNext, Tree_tTree pParameters, Tree_tTree pStmt)
  2773. # else
  2774. (pPos, pNext, pParameters, pStmt)
  2775. Positions_tPosition pPos;
  2776. Tree_tTree pNext;
  2777. Tree_tTree pParameters;
  2778. Tree_tTree pStmt;
  2779. # endif
  2780. {
  2781.   LONGINT yyByteCount;
  2782.   Tree_tTree yyt;
  2783.  
  2784.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2785.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2786.     yyt = Tree_yyAlloc();
  2787.   }
  2788.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_TargetStmt]);
  2789.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2790.   yyt->U_1.V_1.Kind = Tree_TargetStmt;
  2791.   {
  2792.     register Tree_yTargetStmt *W_55 = &yyt->U_1.V_81.TargetStmt;
  2793.  
  2794.     W_55->Pos = pPos;
  2795.     W_55->Next = pNext;
  2796.     W_55->Parameters = pParameters;
  2797.     W_55->Stmt = pStmt;
  2798.   }
  2799.   return yyt;
  2800. }
  2801.  
  2802. Tree_tTree Tree_mNl
  2803. # ifdef __STDC__
  2804. (Positions_tPosition pPos, Tree_tTree pNext)
  2805. # else
  2806. (pPos, pNext)
  2807. Positions_tPosition pPos;
  2808. Tree_tTree pNext;
  2809. # endif
  2810. {
  2811.   LONGINT yyByteCount;
  2812.   Tree_tTree yyt;
  2813.  
  2814.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2815.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2816.     yyt = Tree_yyAlloc();
  2817.   }
  2818.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Nl]);
  2819.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2820.   yyt->U_1.V_1.Kind = Tree_Nl;
  2821.   {
  2822.     register Tree_yNl *W_56 = &yyt->U_1.V_82.Nl;
  2823.  
  2824.     W_56->Pos = pPos;
  2825.     W_56->Next = pNext;
  2826.   }
  2827.   return yyt;
  2828. }
  2829.  
  2830. Tree_tTree Tree_mWriteStr
  2831. # ifdef __STDC__
  2832. (Positions_tPosition pPos, Tree_tTree pNext, StringMem_tStringRef pString)
  2833. # else
  2834. (pPos, pNext, pString)
  2835. Positions_tPosition pPos;
  2836. Tree_tTree pNext;
  2837. StringMem_tStringRef pString;
  2838. # endif
  2839. {
  2840.   LONGINT yyByteCount;
  2841.   Tree_tTree yyt;
  2842.  
  2843.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2844.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2845.     yyt = Tree_yyAlloc();
  2846.   }
  2847.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_WriteStr]);
  2848.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2849.   yyt->U_1.V_1.Kind = Tree_WriteStr;
  2850.   {
  2851.     register Tree_yWriteStr *W_57 = &yyt->U_1.V_83.WriteStr;
  2852.  
  2853.     W_57->Pos = pPos;
  2854.     W_57->Next = pNext;
  2855.     W_57->String = pString;
  2856.   }
  2857.   return yyt;
  2858. }
  2859.  
  2860. Tree_tTree Tree_mFormals
  2861. # ifdef __STDC__
  2862. ()
  2863. # else
  2864. ()
  2865. # endif
  2866. {
  2867.   LONGINT yyByteCount;
  2868.   Tree_tTree yyt;
  2869.  
  2870.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2871.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2872.     yyt = Tree_yyAlloc();
  2873.   }
  2874.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Formals]);
  2875.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2876.   yyt->U_1.V_1.Kind = Tree_Formals;
  2877.   return yyt;
  2878. }
  2879.  
  2880. Tree_tTree Tree_mNoFormal
  2881. # ifdef __STDC__
  2882. ()
  2883. # else
  2884. ()
  2885. # endif
  2886. {
  2887.   LONGINT yyByteCount;
  2888.   Tree_tTree yyt;
  2889.  
  2890.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2891.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2892.     yyt = Tree_yyAlloc();
  2893.   }
  2894.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NoFormal]);
  2895.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2896.   yyt->U_1.V_1.Kind = Tree_NoFormal;
  2897.   return yyt;
  2898. }
  2899.  
  2900. Tree_tTree Tree_mFormal
  2901. # ifdef __STDC__
  2902. (Tree_tTree pNext, Idents_tIdent pName, Tree_tTree pTypeDesc, Tree_tTree pPath)
  2903. # else
  2904. (pNext, pName, pTypeDesc, pPath)
  2905. Tree_tTree pNext;
  2906. Idents_tIdent pName;
  2907. Tree_tTree pTypeDesc;
  2908. Tree_tTree pPath;
  2909. # endif
  2910. {
  2911.   LONGINT yyByteCount;
  2912.   Tree_tTree yyt;
  2913.  
  2914.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2915.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2916.     yyt = Tree_yyAlloc();
  2917.   }
  2918.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Formal]);
  2919.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2920.   yyt->U_1.V_1.Kind = Tree_Formal;
  2921.   {
  2922.     register Tree_yFormal *W_58 = &yyt->U_1.V_86.Formal;
  2923.  
  2924.     W_58->Next = pNext;
  2925.     W_58->Name = pName;
  2926.     W_58->TypeDesc = pTypeDesc;
  2927.     W_58->Path = pPath;
  2928.   }
  2929.   return yyt;
  2930. }
  2931.  
  2932. Tree_tTree Tree_mDummyFormal
  2933. # ifdef __STDC__
  2934. (Tree_tTree pNext)
  2935. # else
  2936. (pNext)
  2937. Tree_tTree pNext;
  2938. # endif
  2939. {
  2940.   LONGINT yyByteCount;
  2941.   Tree_tTree yyt;
  2942.  
  2943.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2944.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2945.     yyt = Tree_yyAlloc();
  2946.   }
  2947.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_DummyFormal]);
  2948.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2949.   yyt->U_1.V_1.Kind = Tree_DummyFormal;
  2950.   {
  2951.     register Tree_yDummyFormal *W_59 = &yyt->U_1.V_87.DummyFormal;
  2952.  
  2953.     W_59->Next = pNext;
  2954.   }
  2955.   return yyt;
  2956. }
  2957.  
  2958. Tree_tTree Tree_mTypeDesc
  2959. # ifdef __STDC__
  2960. ()
  2961. # else
  2962. ()
  2963. # endif
  2964. {
  2965.   LONGINT yyByteCount;
  2966.   Tree_tTree yyt;
  2967.  
  2968.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2969.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2970.     yyt = Tree_yyAlloc();
  2971.   }
  2972.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_TypeDesc]);
  2973.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2974.   yyt->U_1.V_1.Kind = Tree_TypeDesc;
  2975.   return yyt;
  2976. }
  2977.  
  2978. Tree_tTree Tree_mNodeTypes
  2979. # ifdef __STDC__
  2980. (Tree_tTree pTreeName, Sets_tSet pTypes)
  2981. # else
  2982. (pTreeName, pTypes)
  2983. Tree_tTree pTreeName;
  2984. Sets_tSet pTypes;
  2985. # endif
  2986. {
  2987.   LONGINT yyByteCount;
  2988.   Tree_tTree yyt;
  2989.  
  2990.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  2991.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  2992.     yyt = Tree_yyAlloc();
  2993.   }
  2994.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NodeTypes]);
  2995.   yyt->U_1.V_2.yyHead.yyMark = 0;
  2996.   yyt->U_1.V_1.Kind = Tree_NodeTypes;
  2997.   {
  2998.     register Tree_yNodeTypes *W_60 = &yyt->U_1.V_89.NodeTypes;
  2999.  
  3000.     W_60->TreeName = pTreeName;
  3001.     W_60->Types = pTypes;
  3002.   }
  3003.   return yyt;
  3004. }
  3005.  
  3006. Tree_tTree Tree_mUserType
  3007. # ifdef __STDC__
  3008. (Idents_tIdent pType)
  3009. # else
  3010. (pType)
  3011. Idents_tIdent pType;
  3012. # endif
  3013. {
  3014.   LONGINT yyByteCount;
  3015.   Tree_tTree yyt;
  3016.  
  3017.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  3018.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  3019.     yyt = Tree_yyAlloc();
  3020.   }
  3021.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_UserType]);
  3022.   yyt->U_1.V_2.yyHead.yyMark = 0;
  3023.   yyt->U_1.V_1.Kind = Tree_UserType;
  3024.   {
  3025.     register Tree_yUserType *W_61 = &yyt->U_1.V_90.UserType;
  3026.  
  3027.     W_61->Type = pType;
  3028.   }
  3029.   return yyt;
  3030. }
  3031.  
  3032. Tree_tTree Tree_mPath
  3033. # ifdef __STDC__
  3034. ()
  3035. # else
  3036. ()
  3037. # endif
  3038. {
  3039.   LONGINT yyByteCount;
  3040.   Tree_tTree yyt;
  3041.  
  3042.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  3043.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  3044.     yyt = Tree_yyAlloc();
  3045.   }
  3046.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Path]);
  3047.   yyt->U_1.V_2.yyHead.yyMark = 0;
  3048.   yyt->U_1.V_1.Kind = Tree_Path;
  3049.   return yyt;
  3050. }
  3051.  
  3052. Tree_tTree Tree_mVar
  3053. # ifdef __STDC__
  3054. (Idents_tIdent pName, BOOLEAN pIsOutput, BOOLEAN pIsRegister)
  3055. # else
  3056. (pName, pIsOutput, pIsRegister)
  3057. Idents_tIdent pName;
  3058. BOOLEAN pIsOutput;
  3059. BOOLEAN pIsRegister;
  3060. # endif
  3061. {
  3062.   LONGINT yyByteCount;
  3063.   Tree_tTree yyt;
  3064.  
  3065.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  3066.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  3067.     yyt = Tree_yyAlloc();
  3068.   }
  3069.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Var]);
  3070.   yyt->U_1.V_2.yyHead.yyMark = 0;
  3071.   yyt->U_1.V_1.Kind = Tree_Var;
  3072.   {
  3073.     register Tree_yVar *W_62 = &yyt->U_1.V_92.Var;
  3074.  
  3075.     W_62->Name = pName;
  3076.     W_62->IsOutput = pIsOutput;
  3077.     W_62->IsRegister = pIsRegister;
  3078.   }
  3079.   return yyt;
  3080. }
  3081.  
  3082. Tree_tTree Tree_mConsType
  3083. # ifdef __STDC__
  3084. (Tree_tTree pNext, Idents_tIdent pName)
  3085. # else
  3086. (pNext, pName)
  3087. Tree_tTree pNext;
  3088. Idents_tIdent pName;
  3089. # endif
  3090. {
  3091.   LONGINT yyByteCount;
  3092.   Tree_tTree yyt;
  3093.  
  3094.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  3095.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  3096.     yyt = Tree_yyAlloc();
  3097.   }
  3098.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_ConsType]);
  3099.   yyt->U_1.V_2.yyHead.yyMark = 0;
  3100.   yyt->U_1.V_1.Kind = Tree_ConsType;
  3101.   {
  3102.     register Tree_yConsType *W_63 = &yyt->U_1.V_93.ConsType;
  3103.  
  3104.     W_63->Next = pNext;
  3105.     W_63->Name = pName;
  3106.   }
  3107.   return yyt;
  3108. }
  3109.  
  3110. Tree_tTree Tree_mField
  3111. # ifdef __STDC__
  3112. (Tree_tTree pNext, Idents_tIdent pName)
  3113. # else
  3114. (pNext, pName)
  3115. Tree_tTree pNext;
  3116. Idents_tIdent pName;
  3117. # endif
  3118. {
  3119.   LONGINT yyByteCount;
  3120.   Tree_tTree yyt;
  3121.  
  3122.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  3123.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  3124.     yyt = Tree_yyAlloc();
  3125.   }
  3126.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Field]);
  3127.   yyt->U_1.V_2.yyHead.yyMark = 0;
  3128.   yyt->U_1.V_1.Kind = Tree_Field;
  3129.   {
  3130.     register Tree_yField *W_64 = &yyt->U_1.V_94.Field;
  3131.  
  3132.     W_64->Next = pNext;
  3133.     W_64->Name = pName;
  3134.   }
  3135.   return yyt;
  3136. }
  3137.  
  3138. Tree_tTree Tree_mTests
  3139. # ifdef __STDC__
  3140. ()
  3141. # else
  3142. ()
  3143. # endif
  3144. {
  3145.   LONGINT yyByteCount;
  3146.   Tree_tTree yyt;
  3147.  
  3148.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  3149.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  3150.     yyt = Tree_yyAlloc();
  3151.   }
  3152.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Tests]);
  3153.   yyt->U_1.V_2.yyHead.yyMark = 0;
  3154.   yyt->U_1.V_1.Kind = Tree_Tests;
  3155.   return yyt;
  3156. }
  3157.  
  3158. Tree_tTree Tree_mNoTest
  3159. # ifdef __STDC__
  3160. ()
  3161. # else
  3162. ()
  3163. # endif
  3164. {
  3165.   LONGINT yyByteCount;
  3166.   Tree_tTree yyt;
  3167.  
  3168.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  3169.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  3170.     yyt = Tree_yyAlloc();
  3171.   }
  3172.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NoTest]);
  3173.   yyt->U_1.V_2.yyHead.yyMark = 0;
  3174.   yyt->U_1.V_1.Kind = Tree_NoTest;
  3175.   return yyt;
  3176. }
  3177.  
  3178. Tree_tTree Tree_mOneTest
  3179. # ifdef __STDC__
  3180. (Tree_tTree pNext, Tree_tTree pPath)
  3181. # else
  3182. (pNext, pPath)
  3183. Tree_tTree pNext;
  3184. Tree_tTree pPath;
  3185. # endif
  3186. {
  3187.   LONGINT yyByteCount;
  3188.   Tree_tTree yyt;
  3189.  
  3190.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  3191.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  3192.     yyt = Tree_yyAlloc();
  3193.   }
  3194.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_OneTest]);
  3195.   yyt->U_1.V_2.yyHead.yyMark = 0;
  3196.   yyt->U_1.V_1.Kind = Tree_OneTest;
  3197.   {
  3198.     register Tree_yOneTest *W_65 = &yyt->U_1.V_97.OneTest;
  3199.  
  3200.     W_65->Next = pNext;
  3201.     W_65->Path = pPath;
  3202.   }
  3203.   return yyt;
  3204. }
  3205.  
  3206. Tree_tTree Tree_mTestKind
  3207. # ifdef __STDC__
  3208. (Tree_tTree pNext, Tree_tTree pPath, Tree_tTree pTypeDesc, Idents_tIdent pName)
  3209. # else
  3210. (pNext, pPath, pTypeDesc, pName)
  3211. Tree_tTree pNext;
  3212. Tree_tTree pPath;
  3213. Tree_tTree pTypeDesc;
  3214. Idents_tIdent pName;
  3215. # endif
  3216. {
  3217.   LONGINT yyByteCount;
  3218.   Tree_tTree yyt;
  3219.  
  3220.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  3221.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  3222.     yyt = Tree_yyAlloc();
  3223.   }
  3224.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_TestKind]);
  3225.   yyt->U_1.V_2.yyHead.yyMark = 0;
  3226.   yyt->U_1.V_1.Kind = Tree_TestKind;
  3227.   {
  3228.     register Tree_yTestKind *W_66 = &yyt->U_1.V_98.TestKind;
  3229.  
  3230.     W_66->Next = pNext;
  3231.     W_66->Path = pPath;
  3232.     W_66->TypeDesc = pTypeDesc;
  3233.     W_66->Name = pName;
  3234.   }
  3235.   return yyt;
  3236. }
  3237.  
  3238. Tree_tTree Tree_mTestIsType
  3239. # ifdef __STDC__
  3240. (Tree_tTree pNext, Tree_tTree pPath, Tree_tTree pTypeDesc, Idents_tIdent pName)
  3241. # else
  3242. (pNext, pPath, pTypeDesc, pName)
  3243. Tree_tTree pNext;
  3244. Tree_tTree pPath;
  3245. Tree_tTree pTypeDesc;
  3246. Idents_tIdent pName;
  3247. # endif
  3248. {
  3249.   LONGINT yyByteCount;
  3250.   Tree_tTree yyt;
  3251.  
  3252.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  3253.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  3254.     yyt = Tree_yyAlloc();
  3255.   }
  3256.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_TestIsType]);
  3257.   yyt->U_1.V_2.yyHead.yyMark = 0;
  3258.   yyt->U_1.V_1.Kind = Tree_TestIsType;
  3259.   {
  3260.     register Tree_yTestIsType *W_67 = &yyt->U_1.V_99.TestIsType;
  3261.  
  3262.     W_67->Next = pNext;
  3263.     W_67->Path = pPath;
  3264.     W_67->TypeDesc = pTypeDesc;
  3265.     W_67->Name = pName;
  3266.   }
  3267.   return yyt;
  3268. }
  3269.  
  3270. Tree_tTree Tree_mTestNil
  3271. # ifdef __STDC__
  3272. (Tree_tTree pNext, Tree_tTree pPath)
  3273. # else
  3274. (pNext, pPath)
  3275. Tree_tTree pNext;
  3276. Tree_tTree pPath;
  3277. # endif
  3278. {
  3279.   LONGINT yyByteCount;
  3280.   Tree_tTree yyt;
  3281.  
  3282.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  3283.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  3284.     yyt = Tree_yyAlloc();
  3285.   }
  3286.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_TestNil]);
  3287.   yyt->U_1.V_2.yyHead.yyMark = 0;
  3288.   yyt->U_1.V_1.Kind = Tree_TestNil;
  3289.   {
  3290.     register Tree_yTestNil *W_68 = &yyt->U_1.V_100.TestNil;
  3291.  
  3292.     W_68->Next = pNext;
  3293.     W_68->Path = pPath;
  3294.   }
  3295.   return yyt;
  3296. }
  3297.  
  3298. Tree_tTree Tree_mTestNonlin
  3299. # ifdef __STDC__
  3300. (Tree_tTree pNext, Tree_tTree pPath, Tree_tTree pPath2, Tree_tTree pTypeDesc)
  3301. # else
  3302. (pNext, pPath, pPath2, pTypeDesc)
  3303. Tree_tTree pNext;
  3304. Tree_tTree pPath;
  3305. Tree_tTree pPath2;
  3306. Tree_tTree pTypeDesc;
  3307. # endif
  3308. {
  3309.   LONGINT yyByteCount;
  3310.   Tree_tTree yyt;
  3311.  
  3312.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  3313.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  3314.     yyt = Tree_yyAlloc();
  3315.   }
  3316.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_TestNonlin]);
  3317.   yyt->U_1.V_2.yyHead.yyMark = 0;
  3318.   yyt->U_1.V_1.Kind = Tree_TestNonlin;
  3319.   {
  3320.     register Tree_yTestNonlin *W_69 = &yyt->U_1.V_101.TestNonlin;
  3321.  
  3322.     W_69->Next = pNext;
  3323.     W_69->Path = pPath;
  3324.     W_69->Path2 = pPath2;
  3325.     W_69->TypeDesc = pTypeDesc;
  3326.   }
  3327.   return yyt;
  3328. }
  3329.  
  3330. Tree_tTree Tree_mTestValue
  3331. # ifdef __STDC__
  3332. (Tree_tTree pNext, Tree_tTree pPath, Tree_tTree pExpr, Tree_tTree pTypeDesc)
  3333. # else
  3334. (pNext, pPath, pExpr, pTypeDesc)
  3335. Tree_tTree pNext;
  3336. Tree_tTree pPath;
  3337. Tree_tTree pExpr;
  3338. Tree_tTree pTypeDesc;
  3339. # endif
  3340. {
  3341.   LONGINT yyByteCount;
  3342.   Tree_tTree yyt;
  3343.  
  3344.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  3345.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  3346.     yyt = Tree_yyAlloc();
  3347.   }
  3348.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_TestValue]);
  3349.   yyt->U_1.V_2.yyHead.yyMark = 0;
  3350.   yyt->U_1.V_1.Kind = Tree_TestValue;
  3351.   {
  3352.     register Tree_yTestValue *W_70 = &yyt->U_1.V_102.TestValue;
  3353.  
  3354.     W_70->Next = pNext;
  3355.     W_70->Path = pPath;
  3356.     W_70->Expr = pExpr;
  3357.     W_70->TypeDesc = pTypeDesc;
  3358.   }
  3359.   return yyt;
  3360. }
  3361.  
  3362. Tree_tTree Tree_mDecisions
  3363. # ifdef __STDC__
  3364. ()
  3365. # else
  3366. ()
  3367. # endif
  3368. {
  3369.   LONGINT yyByteCount;
  3370.   Tree_tTree yyt;
  3371.  
  3372.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  3373.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  3374.     yyt = Tree_yyAlloc();
  3375.   }
  3376.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Decisions]);
  3377.   yyt->U_1.V_2.yyHead.yyMark = 0;
  3378.   yyt->U_1.V_1.Kind = Tree_Decisions;
  3379.   return yyt;
  3380. }
  3381.  
  3382. Tree_tTree Tree_mNoDecision
  3383. # ifdef __STDC__
  3384. ()
  3385. # else
  3386. ()
  3387. # endif
  3388. {
  3389.   LONGINT yyByteCount;
  3390.   Tree_tTree yyt;
  3391.  
  3392.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  3393.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  3394.     yyt = Tree_yyAlloc();
  3395.   }
  3396.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_NoDecision]);
  3397.   yyt->U_1.V_2.yyHead.yyMark = 0;
  3398.   yyt->U_1.V_1.Kind = Tree_NoDecision;
  3399.   return yyt;
  3400. }
  3401.  
  3402. Tree_tTree Tree_mDecision
  3403. # ifdef __STDC__
  3404. (Tree_tTree pThen, Tree_tTree pElse, Tree_tTree pOneTest, SHORTCARD pCases, BOOLEAN pIsUnchanged)
  3405. # else
  3406. (pThen, pElse, pOneTest, pCases, pIsUnchanged)
  3407. Tree_tTree pThen;
  3408. Tree_tTree pElse;
  3409. Tree_tTree pOneTest;
  3410. SHORTCARD pCases;
  3411. BOOLEAN pIsUnchanged;
  3412. # endif
  3413. {
  3414.   LONGINT yyByteCount;
  3415.   Tree_tTree yyt;
  3416.  
  3417.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  3418.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  3419.     yyt = Tree_yyAlloc();
  3420.   }
  3421.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Decision]);
  3422.   yyt->U_1.V_2.yyHead.yyMark = 0;
  3423.   yyt->U_1.V_1.Kind = Tree_Decision;
  3424.   {
  3425.     register Tree_yDecision *W_71 = &yyt->U_1.V_105.Decision;
  3426.  
  3427.     W_71->Then = pThen;
  3428.     W_71->Else = pElse;
  3429.     W_71->OneTest = pOneTest;
  3430.     W_71->Cases = pCases;
  3431.     W_71->IsUnchanged = pIsUnchanged;
  3432.   }
  3433.   return yyt;
  3434. }
  3435.  
  3436. Tree_tTree Tree_mDecided
  3437. # ifdef __STDC__
  3438. (Tree_tTree pElse, Tree_tTree pRule)
  3439. # else
  3440. (pElse, pRule)
  3441. Tree_tTree pElse;
  3442. Tree_tTree pRule;
  3443. # endif
  3444. {
  3445.   LONGINT yyByteCount;
  3446.   Tree_tTree yyt;
  3447.  
  3448.   yyt = (Tree_tTree)Tree_yyPoolFreePtr;
  3449.   if ((ADDRESS)yyt >= Tree_yyPoolMaxPtr) {
  3450.     yyt = Tree_yyAlloc();
  3451.   }
  3452.   INC1(Tree_yyPoolFreePtr, Tree_yyNodeSize.A[Tree_Decided]);
  3453.   yyt->U_1.V_2.yyHead.yyMark = 0;
  3454.   yyt->U_1.V_1.Kind = Tree_Decided;
  3455.   {
  3456.     register Tree_yDecided *W_72 = &yyt->U_1.V_106.Decided;
  3457.  
  3458.     W_72->Else = pElse;
  3459.     W_72->Rule = pRule;
  3460.   }
  3461.   return yyt;
  3462. }
  3463.  
  3464. static void yyMark
  3465. # ifdef __STDC__
  3466. (Tree_tTree yyt)
  3467. # else
  3468. (yyt)
  3469. Tree_tTree yyt;
  3470. # endif
  3471. {
  3472.   for (;;) {
  3473.     if (yyt == Tree_NoTree) {
  3474.       return;
  3475.     }
  3476.     INC(yyt->U_1.V_2.yyHead.yyMark);
  3477.     if (yyt->U_1.V_2.yyHead.yyMark > 1) {
  3478.       return;
  3479.     }
  3480.     switch (yyt->U_1.V_1.Kind) {
  3481.     case Tree_Class:;
  3482.       yyMark(yyt->U_1.V_5.Class.Attributes);
  3483.       yyMark(yyt->U_1.V_5.Class.Extensions);
  3484.       yyMark(yyt->U_1.V_5.Class.BaseClass);
  3485.       yyMark(yyt->U_1.V_5.Class.Formals);
  3486.       yyMark(yyt->U_1.V_5.Class.TypeDesc);
  3487.       yyt = yyt->U_1.V_5.Class.Next;
  3488.       break;
  3489.     case Tree_AttrOrAction:;
  3490.       yyt = yyt->U_1.V_8.AttrOrAction.Next;
  3491.       break;
  3492.     case Tree_Child:;
  3493.       yyt = yyt->U_1.V_9.Child.Next;
  3494.       break;
  3495.     case Tree_Attribute:;
  3496.       yyt = yyt->U_1.V_10.Attribute.Next;
  3497.       break;
  3498.     case Tree_ActionPart:;
  3499.       yyt = yyt->U_1.V_11.ActionPart.Next;
  3500.       break;
  3501.     case Tree_Designator:;
  3502.       yyt = yyt->U_1.V_15.Designator.Next;
  3503.       break;
  3504.     case Tree_Ident:;
  3505.       yyt = yyt->U_1.V_16.Ident.Next;
  3506.       break;
  3507.     case Tree_Remote:;
  3508.       yyMark(yyt->U_1.V_17.Remote.Designators);
  3509.       yyt = yyt->U_1.V_17.Remote.Next;
  3510.       break;
  3511.     case Tree_Any:;
  3512.       yyt = yyt->U_1.V_18.Any.Next;
  3513.       break;
  3514.     case Tree_Anys:;
  3515.       yyMark(yyt->U_1.V_19.Anys.Layouts);
  3516.       yyt = yyt->U_1.V_19.Anys.Next;
  3517.       break;
  3518.     case Tree_LayoutAny:;
  3519.       yyt = yyt->U_1.V_22.LayoutAny.Next;
  3520.       break;
  3521.     case Tree_Name:;
  3522.       yyt = yyt->U_1.V_25.Name.Next;
  3523.       break;
  3524.     case Tree_Spec:;
  3525.       yyMark(yyt->U_1.V_26.Spec.TreeNames);
  3526.       yyMark(yyt->U_1.V_26.Spec.Public);
  3527.       yyMark(yyt->U_1.V_26.Spec.Extern);
  3528.       yyMark(yyt->U_1.V_26.Spec.Codes);
  3529.       yyt = yyt->U_1.V_26.Spec.Routines;
  3530.       break;
  3531.     case Tree_TreeName:;
  3532.       yyMark(yyt->U_1.V_29.TreeName.Classes);
  3533.       yyt = yyt->U_1.V_29.TreeName.Next;
  3534.       break;
  3535.     case Tree_Routine:;
  3536.       yyMark(yyt->U_1.V_32.Routine.InParams);
  3537.       yyMark(yyt->U_1.V_32.Routine.OutParams);
  3538.       yyMark(yyt->U_1.V_32.Routine.Extern);
  3539.       yyMark(yyt->U_1.V_32.Routine.Rules);
  3540.       yyMark(yyt->U_1.V_32.Routine.InForm);
  3541.       yyMark(yyt->U_1.V_32.Routine.OutForm);
  3542.       yyMark(yyt->U_1.V_32.Routine.ParamDecls);
  3543.       yyMark(yyt->U_1.V_32.Routine.Decisions);
  3544.       yyt = yyt->U_1.V_32.Routine.Next;
  3545.       break;
  3546.     case Tree_Procedure:;
  3547.       yyMark(yyt->U_1.V_33.Procedure.InParams);
  3548.       yyMark(yyt->U_1.V_33.Procedure.OutParams);
  3549.       yyMark(yyt->U_1.V_33.Procedure.Extern);
  3550.       yyMark(yyt->U_1.V_33.Procedure.Rules);
  3551.       yyMark(yyt->U_1.V_33.Procedure.InForm);
  3552.       yyMark(yyt->U_1.V_33.Procedure.OutForm);
  3553.       yyMark(yyt->U_1.V_33.Procedure.ParamDecls);
  3554.       yyMark(yyt->U_1.V_33.Procedure.Decisions);
  3555.       yyt = yyt->U_1.V_33.Procedure.Next;
  3556.       break;
  3557.     case Tree_Function:;
  3558.       yyMark(yyt->U_1.V_34.Function.InParams);
  3559.       yyMark(yyt->U_1.V_34.Function.OutParams);
  3560.       yyMark(yyt->U_1.V_34.Function.Extern);
  3561.       yyMark(yyt->U_1.V_34.Function.Rules);
  3562.       yyMark(yyt->U_1.V_34.Function.InForm);
  3563.       yyMark(yyt->U_1.V_34.Function.OutForm);
  3564.       yyMark(yyt->U_1.V_34.Function.ParamDecls);
  3565.       yyMark(yyt->U_1.V_34.Function.Decisions);
  3566.       yyMark(yyt->U_1.V_34.Function.ReturnParams);
  3567.       yyMark(yyt->U_1.V_34.Function.ReturnForm);
  3568.       yyt = yyt->U_1.V_34.Function.Next;
  3569.       break;
  3570.     case Tree_Predicate:;
  3571.       yyMark(yyt->U_1.V_35.Predicate.InParams);
  3572.       yyMark(yyt->U_1.V_35.Predicate.OutParams);
  3573.       yyMark(yyt->U_1.V_35.Predicate.Extern);
  3574.       yyMark(yyt->U_1.V_35.Predicate.Rules);
  3575.       yyMark(yyt->U_1.V_35.Predicate.InForm);
  3576.       yyMark(yyt->U_1.V_35.Predicate.OutForm);
  3577.       yyMark(yyt->U_1.V_35.Predicate.ParamDecls);
  3578.       yyMark(yyt->U_1.V_35.Predicate.Decisions);
  3579.       yyt = yyt->U_1.V_35.Predicate.Next;
  3580.       break;
  3581.     case Tree_Param:;
  3582.       yyMark(yyt->U_1.V_38.Param.Type);
  3583.       yyt = yyt->U_1.V_38.Param.Next;
  3584.       break;
  3585.     case Tree_Type:;
  3586.       yyt = yyt->U_1.V_39.Type.Names;
  3587.       break;
  3588.     case Tree_Rule:;
  3589.       yyMark(yyt->U_1.V_42.Rule.Patterns);
  3590.       yyMark(yyt->U_1.V_42.Rule.Exprs);
  3591.       yyMark(yyt->U_1.V_42.Rule.Expr);
  3592.       yyMark(yyt->U_1.V_42.Rule.Statements);
  3593.       yyMark(yyt->U_1.V_42.Rule.VarDecls);
  3594.       yyMark(yyt->U_1.V_42.Rule.Tests);
  3595.       yyt = yyt->U_1.V_42.Rule.Next;
  3596.       break;
  3597.     case Tree_OnePattern:;
  3598.       yyMark(yyt->U_1.V_45.OnePattern.Pattern);
  3599.       yyt = yyt->U_1.V_45.OnePattern.Next;
  3600.       break;
  3601.     case Tree_OnePatternsList:;
  3602.       yyMark(yyt->U_1.V_48.OnePatternsList.Patterns);
  3603.       yyt = yyt->U_1.V_48.OnePatternsList.Next;
  3604.       break;
  3605.     case Tree_Pattern:;
  3606.       yyMark(yyt->U_1.V_49.Pattern.TypeDesc);
  3607.       yyt = yyt->U_1.V_49.Pattern.Path;
  3608.       break;
  3609.     case Tree_Decompose:;
  3610.       yyMark(yyt->U_1.V_50.Decompose.TypeDesc);
  3611.       yyMark(yyt->U_1.V_50.Decompose.Path);
  3612.       yyMark(yyt->U_1.V_50.Decompose.Expr);
  3613.       yyt = yyt->U_1.V_50.Decompose.Patterns;
  3614.       break;
  3615.     case Tree_VarDef:;
  3616.       yyMark(yyt->U_1.V_51.VarDef.TypeDesc);
  3617.       yyt = yyt->U_1.V_51.VarDef.Path;
  3618.       break;
  3619.     case Tree_NilTest:;
  3620.       yyMark(yyt->U_1.V_52.NilTest.TypeDesc);
  3621.       yyt = yyt->U_1.V_52.NilTest.Path;
  3622.       break;
  3623.     case Tree_DontCare1:;
  3624.       yyMark(yyt->U_1.V_53.DontCare1.TypeDesc);
  3625.       yyt = yyt->U_1.V_53.DontCare1.Path;
  3626.       break;
  3627.     case Tree_DontCare:;
  3628.       yyMark(yyt->U_1.V_54.DontCare.TypeDesc);
  3629.       yyMark(yyt->U_1.V_54.DontCare.Path);
  3630.       yyt = yyt->U_1.V_54.DontCare.Tempos;
  3631.       break;
  3632.     case Tree_Value:;
  3633.       yyMark(yyt->U_1.V_55.Value.TypeDesc);
  3634.       yyMark(yyt->U_1.V_55.Value.Path);
  3635.       yyt = yyt->U_1.V_55.Value.Expr;
  3636.       break;
  3637.     case Tree_OneExpr:;
  3638.       yyMark(yyt->U_1.V_58.OneExpr.Expr);
  3639.       yyt = yyt->U_1.V_58.OneExpr.Next;
  3640.       break;
  3641.     case Tree_NamedExpr:;
  3642.       yyMark(yyt->U_1.V_59.NamedExpr.Expr);
  3643.       yyt = yyt->U_1.V_59.NamedExpr.Next;
  3644.       break;
  3645.     case Tree_Compose:;
  3646.       yyMark(yyt->U_1.V_61.Compose.Expr);
  3647.       yyMark(yyt->U_1.V_61.Compose.Exprs);
  3648.       yyt = yyt->U_1.V_61.Compose.TypeDesc;
  3649.       break;
  3650.     case Tree_Call:;
  3651.       yyMark(yyt->U_1.V_65.Call.Expr);
  3652.       yyMark(yyt->U_1.V_65.Call.Exprs);
  3653.       yyt = yyt->U_1.V_65.Call.Patterns;
  3654.       break;
  3655.     case Tree_Binary:;
  3656.       yyMark(yyt->U_1.V_66.Binary.Lop);
  3657.       yyt = yyt->U_1.V_66.Binary.Rop;
  3658.       break;
  3659.     case Tree_PreOperator:;
  3660.       yyt = yyt->U_1.V_67.PreOperator.Expr;
  3661.       break;
  3662.     case Tree_PostOperator:;
  3663.       yyt = yyt->U_1.V_68.PostOperator.Expr;
  3664.       break;
  3665.     case Tree_Index:;
  3666.       yyMark(yyt->U_1.V_69.Index.Expr);
  3667.       yyt = yyt->U_1.V_69.Index.Exprs;
  3668.       break;
  3669.     case Tree_Parents:;
  3670.       yyt = yyt->U_1.V_70.Parents.Expr;
  3671.       break;
  3672.     case Tree_TargetExpr:;
  3673.       yyt = yyt->U_1.V_71.TargetExpr.Expr;
  3674.       break;
  3675.     case Tree_Statement:;
  3676.       yyt = yyt->U_1.V_75.Statement.Next;
  3677.       break;
  3678.     case Tree_ProcCall:;
  3679.       yyMark(yyt->U_1.V_76.ProcCall.Call);
  3680.       yyt = yyt->U_1.V_76.ProcCall.Next;
  3681.       break;
  3682.     case Tree_Condition:;
  3683.       yyMark(yyt->U_1.V_77.Condition.Expr);
  3684.       yyt = yyt->U_1.V_77.Condition.Next;
  3685.       break;
  3686.     case Tree_Assignment:;
  3687.       yyMark(yyt->U_1.V_78.Assignment.Adr);
  3688.       yyMark(yyt->U_1.V_78.Assignment.Expr);
  3689.       yyt = yyt->U_1.V_78.Assignment.Next;
  3690.       break;
  3691.     case Tree_Reject:;
  3692.       yyt = yyt->U_1.V_79.Reject.Next;
  3693.       break;
  3694.     case Tree_Fail:;
  3695.       yyt = yyt->U_1.V_80.Fail.Next;
  3696.       break;
  3697.     case Tree_TargetStmt:;
  3698.       yyMark(yyt->U_1.V_81.TargetStmt.Parameters);
  3699.       yyMark(yyt->U_1.V_81.TargetStmt.Stmt);
  3700.       yyt = yyt->U_1.V_81.TargetStmt.Next;
  3701.       break;
  3702.     case Tree_Nl:;
  3703.       yyt = yyt->U_1.V_82.Nl.Next;
  3704.       break;
  3705.     case Tree_WriteStr:;
  3706.       yyt = yyt->U_1.V_83.WriteStr.Next;
  3707.       break;
  3708.     case Tree_Formal:;
  3709.       yyMark(yyt->U_1.V_86.Formal.TypeDesc);
  3710.       yyMark(yyt->U_1.V_86.Formal.Path);
  3711.       yyt = yyt->U_1.V_86.Formal.Next;
  3712.       break;
  3713.     case Tree_DummyFormal:;
  3714.       yyt = yyt->U_1.V_87.DummyFormal.Next;
  3715.       break;
  3716.     case Tree_NodeTypes:;
  3717.       yyt = yyt->U_1.V_89.NodeTypes.TreeName;
  3718.       break;
  3719.     case Tree_ConsType:;
  3720.       yyt = yyt->U_1.V_93.ConsType.Next;
  3721.       break;
  3722.     case Tree_Field:;
  3723.       yyt = yyt->U_1.V_94.Field.Next;
  3724.       break;
  3725.     case Tree_OneTest:;
  3726.       yyMark(yyt->U_1.V_97.OneTest.Next);
  3727.       yyt = yyt->U_1.V_97.OneTest.Path;
  3728.       break;
  3729.     case Tree_TestKind:;
  3730.       yyMark(yyt->U_1.V_98.TestKind.Next);
  3731.       yyMark(yyt->U_1.V_98.TestKind.Path);
  3732.       yyt = yyt->U_1.V_98.TestKind.TypeDesc;
  3733.       break;
  3734.     case Tree_TestIsType:;
  3735.       yyMark(yyt->U_1.V_99.TestIsType.Next);
  3736.       yyMark(yyt->U_1.V_99.TestIsType.Path);
  3737.       yyt = yyt->U_1.V_99.TestIsType.TypeDesc;
  3738.       break;
  3739.     case Tree_TestNil:;
  3740.       yyMark(yyt->U_1.V_100.TestNil.Next);
  3741.       yyt = yyt->U_1.V_100.TestNil.Path;
  3742.       break;
  3743.     case Tree_TestNonlin:;
  3744.       yyMark(yyt->U_1.V_101.TestNonlin.Next);
  3745.       yyMark(yyt->U_1.V_101.TestNonlin.Path);
  3746.       yyMark(yyt->U_1.V_101.TestNonlin.Path2);
  3747.       yyt = yyt->U_1.V_101.TestNonlin.TypeDesc;
  3748.       break;
  3749.     case Tree_TestValue:;
  3750.       yyMark(yyt->U_1.V_102.TestValue.Next);
  3751.       yyMark(yyt->U_1.V_102.TestValue.Path);
  3752.       yyMark(yyt->U_1.V_102.TestValue.Expr);
  3753.       yyt = yyt->U_1.V_102.TestValue.TypeDesc;
  3754.       break;
  3755.     case Tree_Decision:;
  3756.       yyMark(yyt->U_1.V_105.Decision.Then);
  3757.       yyMark(yyt->U_1.V_105.Decision.Else);
  3758.       yyt = yyt->U_1.V_105.Decision.OneTest;
  3759.       break;
  3760.     case Tree_Decided:;
  3761.       yyMark(yyt->U_1.V_106.Decided.Else);
  3762.       yyt = yyt->U_1.V_106.Decided.Rule;
  3763.       break;
  3764.     default :
  3765.       return;
  3766.       break;
  3767.     }
  3768.   } EXIT_3:;
  3769. }
  3770.  
  3771. static void yyWriteNl
  3772. # ifdef __STDC__
  3773. ()
  3774. # else
  3775. ()
  3776. # endif
  3777. {
  3778.   IO_WriteNl(yyf);
  3779. }
  3780.  
  3781. static void yyWriteSelector
  3782. # ifdef __STDC__
  3783. (CHAR yys[], LONGCARD O_1)
  3784. # else
  3785. (yys, O_1)
  3786. CHAR yys[];
  3787. LONGCARD O_1;
  3788. # endif
  3789. {
  3790.   OPEN_ARRAY_LOCALS
  3791.  
  3792.   ALLOC_OPEN_ARRAYS(O_1 * sizeof(CHAR), 1)
  3793.   COPY_OPEN_ARRAY(yys, O_1, CHAR)
  3794.   IO_WriteS(yyf, yys, O_1);
  3795.   Layout_WriteSpaces(yyf, 15 - (INTEGER)(O_1 - 1));
  3796.   IO_WriteS(yyf, (STRING)" = ", 3L);
  3797.   FREE_OPEN_ARRAYS
  3798. }
  3799.  
  3800. static void yyWriteHex
  3801. # ifdef __STDC__
  3802. (BYTE yyx[], LONGCARD O_2)
  3803. # else
  3804. (yyx, O_2)
  3805. BYTE yyx[];
  3806. LONGCARD O_2;
  3807. # endif
  3808. {
  3809.   INTEGER yyi;
  3810.  
  3811.   {
  3812.     LONGINT B_5 = 0, B_6 = (INTEGER)(O_2 - 1);
  3813.  
  3814.     if (B_5 <= B_6)
  3815.       for (yyi = B_5;; yyi += 1) {
  3816.         IO_WriteN(yyf, ORD((CHAR)yyx[yyi]), 2L, 16L);
  3817.         IO_WriteC(yyf, ' ');
  3818.         if (yyi >= B_6) break;
  3819.       }
  3820.   }
  3821. }
  3822.  
  3823. static void yyWriteAdr
  3824. # ifdef __STDC__
  3825. (Tree_tTree yyt)
  3826. # else
  3827. (yyt)
  3828. Tree_tTree yyt;
  3829. # endif
  3830. {
  3831.   if (yyt == Tree_NoTree) {
  3832.     IO_WriteS(yyf, (STRING)"NoTree", 6L);
  3833.   } else {
  3834.     yyWriteHex((WORD *)&yyt, (LONGCARD)sizeof(yyt));
  3835.   }
  3836.   yyWriteNl();
  3837. }
  3838.  
  3839. static void yWriteNodeClass
  3840. # ifdef __STDC__
  3841. (Tree_tTree yyt)
  3842. # else
  3843. (yyt)
  3844. Tree_tTree yyt;
  3845. # endif
  3846. {
  3847.   yyWriteSelector((STRING)"Name", 4L);
  3848.   Idents_WriteIdent(yyf, yyt->U_1.V_5.Class.Name);
  3849.   yyWriteNl();
  3850.   yyWriteSelector((STRING)"Properties", 10L);
  3851.   yyWriteHex((WORD *)&yyt->U_1.V_5.Class.Properties, (LONGCARD)sizeof(yyt->U_1.V_5.Class.Properties));
  3852.   yyWriteNl();
  3853.   yyWriteSelector((STRING)"Attributes", 10L);
  3854.   yyWriteAdr(yyt->U_1.V_5.Class.Attributes);
  3855.   yyWriteSelector((STRING)"Extensions", 10L);
  3856.   yyWriteAdr(yyt->U_1.V_5.Class.Extensions);
  3857.   yyWriteSelector((STRING)"Next", 4L);
  3858.   yyWriteAdr(yyt->U_1.V_5.Class.Next);
  3859.   yyWriteSelector((STRING)"BaseClass", 9L);
  3860.   yyWriteAdr(yyt->U_1.V_5.Class.BaseClass);
  3861.   yyWriteSelector((STRING)"Formals", 7L);
  3862.   yyWriteAdr(yyt->U_1.V_5.Class.Formals);
  3863.   yyWriteSelector((STRING)"TypeDesc", 8L);
  3864.   yyWriteAdr(yyt->U_1.V_5.Class.TypeDesc);
  3865.   yyWriteSelector((STRING)"Index", 5L);
  3866.   IO_WriteI(yyf, (LONGINT)yyt->U_1.V_5.Class.Index, 0L);
  3867.   yyWriteNl();
  3868. }
  3869.  
  3870. static void yWriteNodeAttrOrAction
  3871. # ifdef __STDC__
  3872. (Tree_tTree yyt)
  3873. # else
  3874. (yyt)
  3875. Tree_tTree yyt;
  3876. # endif
  3877. {
  3878.   yyWriteSelector((STRING)"Next", 4L);
  3879.   yyWriteAdr(yyt->U_1.V_8.AttrOrAction.Next);
  3880. }
  3881.  
  3882. static void yWriteNodeChild
  3883. # ifdef __STDC__
  3884. (Tree_tTree yyt)
  3885. # else
  3886. (yyt)
  3887. Tree_tTree yyt;
  3888. # endif
  3889. {
  3890.   yWriteNodeAttrOrAction(yyt);
  3891.   yyWriteSelector((STRING)"Name", 4L);
  3892.   Idents_WriteIdent(yyf, yyt->U_1.V_9.Child.Name);
  3893.   yyWriteNl();
  3894.   yyWriteSelector((STRING)"Type", 4L);
  3895.   Idents_WriteIdent(yyf, yyt->U_1.V_9.Child.Type);
  3896.   yyWriteNl();
  3897.   yyWriteSelector((STRING)"Properties", 10L);
  3898.   yyWriteHex((WORD *)&yyt->U_1.V_9.Child.Properties, (LONGCARD)sizeof(yyt->U_1.V_9.Child.Properties));
  3899.   yyWriteNl();
  3900. }
  3901.  
  3902. static void yWriteNodeAttribute
  3903. # ifdef __STDC__
  3904. (Tree_tTree yyt)
  3905. # else
  3906. (yyt)
  3907. Tree_tTree yyt;
  3908. # endif
  3909. {
  3910.   yWriteNodeAttrOrAction(yyt);
  3911.   yyWriteSelector((STRING)"Name", 4L);
  3912.   Idents_WriteIdent(yyf, yyt->U_1.V_10.Attribute.Name);
  3913.   yyWriteNl();
  3914.   yyWriteSelector((STRING)"Type", 4L);
  3915.   Idents_WriteIdent(yyf, yyt->U_1.V_10.Attribute.Type);
  3916.   yyWriteNl();
  3917.   yyWriteSelector((STRING)"Properties", 10L);
  3918.   yyWriteHex((WORD *)&yyt->U_1.V_10.Attribute.Properties, (LONGCARD)sizeof(yyt->U_1.V_10.Attribute.Properties));
  3919.   yyWriteNl();
  3920. }
  3921.  
  3922. static void yWriteNodeActionPart
  3923. # ifdef __STDC__
  3924. (Tree_tTree yyt)
  3925. # else
  3926. (yyt)
  3927. Tree_tTree yyt;
  3928. # endif
  3929. {
  3930.   yWriteNodeAttrOrAction(yyt);
  3931. }
  3932.  
  3933. static void yWriteNodeCodes
  3934. # ifdef __STDC__
  3935. (Tree_tTree yyt)
  3936. # else
  3937. (yyt)
  3938. Tree_tTree yyt;
  3939. # endif
  3940. {
  3941.   yyWriteSelector((STRING)"Export", 6L);
  3942.   Texts_WriteText(yyf, yyt->U_1.V_12.Codes.Export);
  3943.   yyWriteNl();
  3944.   yyWriteSelector((STRING)"Import", 6L);
  3945.   Texts_WriteText(yyf, yyt->U_1.V_12.Codes.Import);
  3946.   yyWriteNl();
  3947.   yyWriteSelector((STRING)"Global", 6L);
  3948.   Texts_WriteText(yyf, yyt->U_1.V_12.Codes.Global);
  3949.   yyWriteNl();
  3950.   yyWriteSelector((STRING)"Local", 5L);
  3951.   Texts_WriteText(yyf, yyt->U_1.V_12.Codes.Local);
  3952.   yyWriteNl();
  3953.   yyWriteSelector((STRING)"Begin", 5L);
  3954.   Texts_WriteText(yyf, yyt->U_1.V_12.Codes.Begin);
  3955.   yyWriteNl();
  3956.   yyWriteSelector((STRING)"Close", 5L);
  3957.   Texts_WriteText(yyf, yyt->U_1.V_12.Codes.Close);
  3958.   yyWriteNl();
  3959.   yyWriteSelector((STRING)"ExportLine", 10L);
  3960.   Positions_WritePosition(yyf, yyt->U_1.V_12.Codes.ExportLine);
  3961.   yyWriteNl();
  3962.   yyWriteSelector((STRING)"ImportLine", 10L);
  3963.   Positions_WritePosition(yyf, yyt->U_1.V_12.Codes.ImportLine);
  3964.   yyWriteNl();
  3965.   yyWriteSelector((STRING)"GlobalLine", 10L);
  3966.   Positions_WritePosition(yyf, yyt->U_1.V_12.Codes.GlobalLine);
  3967.   yyWriteNl();
  3968.   yyWriteSelector((STRING)"LocalLine", 9L);
  3969.   Positions_WritePosition(yyf, yyt->U_1.V_12.Codes.LocalLine);
  3970.   yyWriteNl();
  3971.   yyWriteSelector((STRING)"BeginLine", 9L);
  3972.   Positions_WritePosition(yyf, yyt->U_1.V_12.Codes.BeginLine);
  3973.   yyWriteNl();
  3974.   yyWriteSelector((STRING)"CloseLine", 9L);
  3975.   Positions_WritePosition(yyf, yyt->U_1.V_12.Codes.CloseLine);
  3976.   yyWriteNl();
  3977. }
  3978.  
  3979. static void yWriteNodeDesignator
  3980. # ifdef __STDC__
  3981. (Tree_tTree yyt)
  3982. # else
  3983. (yyt)
  3984. Tree_tTree yyt;
  3985. # endif
  3986. {
  3987.   yyWriteSelector((STRING)"Selector", 8L);
  3988.   Idents_WriteIdent(yyf, yyt->U_1.V_15.Designator.Selector);
  3989.   yyWriteNl();
  3990.   yyWriteSelector((STRING)"Attribute", 9L);
  3991.   Idents_WriteIdent(yyf, yyt->U_1.V_15.Designator.Attribute);
  3992.   yyWriteNl();
  3993.   yyWriteSelector((STRING)"Pos", 3L);
  3994.   Positions_WritePosition(yyf, yyt->U_1.V_15.Designator.Pos);
  3995.   yyWriteNl();
  3996.   yyWriteSelector((STRING)"Next", 4L);
  3997.   yyWriteAdr(yyt->U_1.V_15.Designator.Next);
  3998.   yyWriteSelector((STRING)"Object", 6L);
  3999.   yyWriteHex((WORD *)&yyt->U_1.V_15.Designator.Object, (LONGCARD)sizeof(yyt->U_1.V_15.Designator.Object));
  4000.   yyWriteNl();
  4001.   yyWriteSelector((STRING)"Type", 4L);
  4002.   Idents_WriteIdent(yyf, yyt->U_1.V_15.Designator.Type);
  4003.   yyWriteNl();
  4004. }
  4005.  
  4006. static void yWriteNodeIdent
  4007. # ifdef __STDC__
  4008. (Tree_tTree yyt)
  4009. # else
  4010. (yyt)
  4011. Tree_tTree yyt;
  4012. # endif
  4013. {
  4014.   yyWriteSelector((STRING)"Attribute", 9L);
  4015.   Idents_WriteIdent(yyf, yyt->U_1.V_16.Ident.Attribute);
  4016.   yyWriteNl();
  4017.   yyWriteSelector((STRING)"Pos", 3L);
  4018.   Positions_WritePosition(yyf, yyt->U_1.V_16.Ident.Pos);
  4019.   yyWriteNl();
  4020.   yyWriteSelector((STRING)"Next", 4L);
  4021.   yyWriteAdr(yyt->U_1.V_16.Ident.Next);
  4022. }
  4023.  
  4024. static void yWriteNodeRemote
  4025. # ifdef __STDC__
  4026. (Tree_tTree yyt)
  4027. # else
  4028. (yyt)
  4029. Tree_tTree yyt;
  4030. # endif
  4031. {
  4032.   yyWriteSelector((STRING)"Designators", 11L);
  4033.   yyWriteAdr(yyt->U_1.V_17.Remote.Designators);
  4034.   yyWriteSelector((STRING)"Type", 4L);
  4035.   Idents_WriteIdent(yyf, yyt->U_1.V_17.Remote.Type);
  4036.   yyWriteNl();
  4037.   yyWriteSelector((STRING)"Attribute", 9L);
  4038.   Idents_WriteIdent(yyf, yyt->U_1.V_17.Remote.Attribute);
  4039.   yyWriteNl();
  4040.   yyWriteSelector((STRING)"Pos", 3L);
  4041.   Positions_WritePosition(yyf, yyt->U_1.V_17.Remote.Pos);
  4042.   yyWriteNl();
  4043.   yyWriteSelector((STRING)"Next", 4L);
  4044.   yyWriteAdr(yyt->U_1.V_17.Remote.Next);
  4045. }
  4046.  
  4047. static void yWriteNodeAny
  4048. # ifdef __STDC__
  4049. (Tree_tTree yyt)
  4050. # else
  4051. (yyt)
  4052. Tree_tTree yyt;
  4053. # endif
  4054. {
  4055.   yyWriteSelector((STRING)"Code", 4L);
  4056.   StringMem_WriteString(yyf, yyt->U_1.V_18.Any.Code);
  4057.   yyWriteNl();
  4058.   yyWriteSelector((STRING)"Next", 4L);
  4059.   yyWriteAdr(yyt->U_1.V_18.Any.Next);
  4060. }
  4061.  
  4062. static void yWriteNodeAnys
  4063. # ifdef __STDC__
  4064. (Tree_tTree yyt)
  4065. # else
  4066. (yyt)
  4067. Tree_tTree yyt;
  4068. # endif
  4069. {
  4070.   yyWriteSelector((STRING)"Layouts", 7L);
  4071.   yyWriteAdr(yyt->U_1.V_19.Anys.Layouts);
  4072.   yyWriteSelector((STRING)"Next", 4L);
  4073.   yyWriteAdr(yyt->U_1.V_19.Anys.Next);
  4074. }
  4075.  
  4076. static void yWriteNodeLayoutAny
  4077. # ifdef __STDC__
  4078. (Tree_tTree yyt)
  4079. # else
  4080. (yyt)
  4081. Tree_tTree yyt;
  4082. # endif
  4083. {
  4084.   yyWriteSelector((STRING)"Code", 4L);
  4085.   StringMem_WriteString(yyf, yyt->U_1.V_22.LayoutAny.Code);
  4086.   yyWriteNl();
  4087.   yyWriteSelector((STRING)"Next", 4L);
  4088.   yyWriteAdr(yyt->U_1.V_22.LayoutAny.Next);
  4089. }
  4090.  
  4091. static void yWriteNodeName
  4092. # ifdef __STDC__
  4093. (Tree_tTree yyt)
  4094. # else
  4095. (yyt)
  4096. Tree_tTree yyt;
  4097. # endif
  4098. {
  4099.   yyWriteSelector((STRING)"Name", 4L);
  4100.   Idents_WriteIdent(yyf, yyt->U_1.V_25.Name.Name);
  4101.   yyWriteNl();
  4102.   yyWriteSelector((STRING)"Pos", 3L);
  4103.   Positions_WritePosition(yyf, yyt->U_1.V_25.Name.Pos);
  4104.   yyWriteNl();
  4105.   yyWriteSelector((STRING)"Next", 4L);
  4106.   yyWriteAdr(yyt->U_1.V_25.Name.Next);
  4107.   yyWriteSelector((STRING)"Object", 6L);
  4108.   yyWriteHex((WORD *)&yyt->U_1.V_25.Name.Object, (LONGCARD)sizeof(yyt->U_1.V_25.Name.Object));
  4109.   yyWriteNl();
  4110. }
  4111.  
  4112. static void yWriteNodeSpec
  4113. # ifdef __STDC__
  4114. (Tree_tTree yyt)
  4115. # else
  4116. (yyt)
  4117. Tree_tTree yyt;
  4118. # endif
  4119. {
  4120.   yyWriteSelector((STRING)"TrafoName", 9L);
  4121.   Idents_WriteIdent(yyf, yyt->U_1.V_26.Spec.TrafoName);
  4122.   yyWriteNl();
  4123.   yyWriteSelector((STRING)"TreeNames", 9L);
  4124.   yyWriteAdr(yyt->U_1.V_26.Spec.TreeNames);
  4125.   yyWriteSelector((STRING)"Public", 6L);
  4126.   yyWriteAdr(yyt->U_1.V_26.Spec.Public);
  4127.   yyWriteSelector((STRING)"Extern", 6L);
  4128.   yyWriteAdr(yyt->U_1.V_26.Spec.Extern);
  4129.   yyWriteSelector((STRING)"Codes", 5L);
  4130.   yyWriteAdr(yyt->U_1.V_26.Spec.Codes);
  4131.   yyWriteSelector((STRING)"Routines", 8L);
  4132.   yyWriteAdr(yyt->U_1.V_26.Spec.Routines);
  4133. }
  4134.  
  4135. static void yWriteNodeTreeName
  4136. # ifdef __STDC__
  4137. (Tree_tTree yyt)
  4138. # else
  4139. (yyt)
  4140. Tree_tTree yyt;
  4141. # endif
  4142. {
  4143.   yyWriteSelector((STRING)"Name", 4L);
  4144.   Idents_WriteIdent(yyf, yyt->U_1.V_29.TreeName.Name);
  4145.   yyWriteNl();
  4146.   yyWriteSelector((STRING)"Pos", 3L);
  4147.   Positions_WritePosition(yyf, yyt->U_1.V_29.TreeName.Pos);
  4148.   yyWriteNl();
  4149.   yyWriteSelector((STRING)"Next", 4L);
  4150.   yyWriteAdr(yyt->U_1.V_29.TreeName.Next);
  4151.   yyWriteSelector((STRING)"Classes", 7L);
  4152.   yyWriteAdr(yyt->U_1.V_29.TreeName.Classes);
  4153.   yyWriteSelector((STRING)"ClassCount", 10L);
  4154.   IO_WriteI(yyf, (LONGINT)yyt->U_1.V_29.TreeName.ClassCount, 0L);
  4155.   yyWriteNl();
  4156. }
  4157.  
  4158. static void yWriteNodeRoutine
  4159. # ifdef __STDC__
  4160. (Tree_tTree yyt)
  4161. # else
  4162. (yyt)
  4163. Tree_tTree yyt;
  4164. # endif
  4165. {
  4166.   yyWriteSelector((STRING)"Next", 4L);
  4167.   yyWriteAdr(yyt->U_1.V_32.Routine.Next);
  4168.   yyWriteSelector((STRING)"Name", 4L);
  4169.   Idents_WriteIdent(yyf, yyt->U_1.V_32.Routine.Name);
  4170.   yyWriteNl();
  4171.   yyWriteSelector((STRING)"Pos", 3L);
  4172.   Positions_WritePosition(yyf, yyt->U_1.V_32.Routine.Pos);
  4173.   yyWriteNl();
  4174.   yyWriteSelector((STRING)"InParams", 8L);
  4175.   yyWriteAdr(yyt->U_1.V_32.Routine.InParams);
  4176.   yyWriteSelector((STRING)"OutParams", 9L);
  4177.   yyWriteAdr(yyt->U_1.V_32.Routine.OutParams);
  4178.   yyWriteSelector((STRING)"Extern", 6L);
  4179.   yyWriteAdr(yyt->U_1.V_32.Routine.Extern);
  4180.   yyWriteSelector((STRING)"Local", 5L);
  4181.   Texts_WriteText(yyf, yyt->U_1.V_32.Routine.Local);
  4182.   yyWriteNl();
  4183.   yyWriteSelector((STRING)"LocalLine", 9L);
  4184.   Positions_WritePosition(yyf, yyt->U_1.V_32.Routine.LocalLine);
  4185.   yyWriteNl();
  4186.   yyWriteSelector((STRING)"Rules", 5L);
  4187.   yyWriteAdr(yyt->U_1.V_32.Routine.Rules);
  4188.   yyWriteSelector((STRING)"InForm", 6L);
  4189.   yyWriteAdr(yyt->U_1.V_32.Routine.InForm);
  4190.   yyWriteSelector((STRING)"OutForm", 7L);
  4191.   yyWriteAdr(yyt->U_1.V_32.Routine.OutForm);
  4192.   yyWriteSelector((STRING)"ParamDecls", 10L);
  4193.   yyWriteAdr(yyt->U_1.V_32.Routine.ParamDecls);
  4194.   yyWriteSelector((STRING)"IsExtern", 8L);
  4195.   IO_WriteB(yyf, yyt->U_1.V_32.Routine.IsExtern);
  4196.   yyWriteNl();
  4197.   yyWriteSelector((STRING)"Decisions", 9L);
  4198.   yyWriteAdr(yyt->U_1.V_32.Routine.Decisions);
  4199. }
  4200.  
  4201. static void yWriteNodeProcedure
  4202. # ifdef __STDC__
  4203. (Tree_tTree yyt)
  4204. # else
  4205. (yyt)
  4206. Tree_tTree yyt;
  4207. # endif
  4208. {
  4209.   yWriteNodeRoutine(yyt);
  4210. }
  4211.  
  4212. static void yWriteNodeFunction
  4213. # ifdef __STDC__
  4214. (Tree_tTree yyt)
  4215. # else
  4216. (yyt)
  4217. Tree_tTree yyt;
  4218. # endif
  4219. {
  4220.   yWriteNodeRoutine(yyt);
  4221.   yyWriteSelector((STRING)"ReturnParams", 12L);
  4222.   yyWriteAdr(yyt->U_1.V_34.Function.ReturnParams);
  4223.   yyWriteSelector((STRING)"ReturnForm", 10L);
  4224.   yyWriteAdr(yyt->U_1.V_34.Function.ReturnForm);
  4225. }
  4226.  
  4227. static void yWriteNodePredicate
  4228. # ifdef __STDC__
  4229. (Tree_tTree yyt)
  4230. # else
  4231. (yyt)
  4232. Tree_tTree yyt;
  4233. # endif
  4234. {
  4235.   yWriteNodeRoutine(yyt);
  4236. }
  4237.  
  4238. static void yWriteNodeParam
  4239. # ifdef __STDC__
  4240. (Tree_tTree yyt)
  4241. # else
  4242. (yyt)
  4243. Tree_tTree yyt;
  4244. # endif
  4245. {
  4246.   yyWriteSelector((STRING)"IsRef", 5L);
  4247.   IO_WriteB(yyf, yyt->U_1.V_38.Param.IsRef);
  4248.   yyWriteNl();
  4249.   yyWriteSelector((STRING)"Name", 4L);
  4250.   Idents_WriteIdent(yyf, yyt->U_1.V_38.Param.Name);
  4251.   yyWriteNl();
  4252.   yyWriteSelector((STRING)"Pos", 3L);
  4253.   Positions_WritePosition(yyf, yyt->U_1.V_38.Param.Pos);
  4254.   yyWriteNl();
  4255.   yyWriteSelector((STRING)"Type", 4L);
  4256.   yyWriteAdr(yyt->U_1.V_38.Param.Type);
  4257.   yyWriteSelector((STRING)"Next", 4L);
  4258.   yyWriteAdr(yyt->U_1.V_38.Param.Next);
  4259. }
  4260.  
  4261. static void yWriteNodeType
  4262. # ifdef __STDC__
  4263. (Tree_tTree yyt)
  4264. # else
  4265. (yyt)
  4266. Tree_tTree yyt;
  4267. # endif
  4268. {
  4269.   yyWriteSelector((STRING)"Name", 4L);
  4270.   Idents_WriteIdent(yyf, yyt->U_1.V_39.Type.Name);
  4271.   yyWriteNl();
  4272.   yyWriteSelector((STRING)"Pos", 3L);
  4273.   Positions_WritePosition(yyf, yyt->U_1.V_39.Type.Pos);
  4274.   yyWriteNl();
  4275.   yyWriteSelector((STRING)"Names", 5L);
  4276.   yyWriteAdr(yyt->U_1.V_39.Type.Names);
  4277. }
  4278.  
  4279. static void yWriteNodeRule
  4280. # ifdef __STDC__
  4281. (Tree_tTree yyt)
  4282. # else
  4283. (yyt)
  4284. Tree_tTree yyt;
  4285. # endif
  4286. {
  4287.   yyWriteSelector((STRING)"Line", 4L);
  4288.   Positions_WritePosition(yyf, yyt->U_1.V_42.Rule.Line);
  4289.   yyWriteNl();
  4290.   yyWriteSelector((STRING)"Patterns", 8L);
  4291.   yyWriteAdr(yyt->U_1.V_42.Rule.Patterns);
  4292.   yyWriteSelector((STRING)"Exprs", 5L);
  4293.   yyWriteAdr(yyt->U_1.V_42.Rule.Exprs);
  4294.   yyWriteSelector((STRING)"Expr", 4L);
  4295.   yyWriteAdr(yyt->U_1.V_42.Rule.Expr);
  4296.   yyWriteSelector((STRING)"Statements", 10L);
  4297.   yyWriteAdr(yyt->U_1.V_42.Rule.Statements);
  4298.   yyWriteSelector((STRING)"Next", 4L);
  4299.   yyWriteAdr(yyt->U_1.V_42.Rule.Next);
  4300.   yyWriteSelector((STRING)"VarDecls", 8L);
  4301.   yyWriteAdr(yyt->U_1.V_42.Rule.VarDecls);
  4302.   yyWriteSelector((STRING)"HasTempos", 9L);
  4303.   IO_WriteB(yyf, yyt->U_1.V_42.Rule.HasTempos);
  4304.   yyWriteNl();
  4305.   yyWriteSelector((STRING)"HasPatterns", 11L);
  4306.   IO_WriteB(yyf, yyt->U_1.V_42.Rule.HasPatterns);
  4307.   yyWriteNl();
  4308.   yyWriteSelector((STRING)"Tempo", 5L);
  4309.   Idents_WriteIdent(yyf, yyt->U_1.V_42.Rule.Tempo);
  4310.   yyWriteNl();
  4311.   yyWriteSelector((STRING)"Index", 5L);
  4312.   IO_WriteI(yyf, (LONGINT)yyt->U_1.V_42.Rule.Index, 0L);
  4313.   yyWriteNl();
  4314.   yyWriteSelector((STRING)"Tests", 5L);
  4315.   yyWriteAdr(yyt->U_1.V_42.Rule.Tests);
  4316.   yyWriteSelector((STRING)"HasExit", 7L);
  4317.   IO_WriteB(yyf, yyt->U_1.V_42.Rule.HasExit);
  4318.   yyWriteNl();
  4319.   yyWriteSelector((STRING)"HasAssign", 9L);
  4320.   IO_WriteB(yyf, yyt->U_1.V_42.Rule.HasAssign);
  4321.   yyWriteNl();
  4322.   yyWriteSelector((STRING)"HasTargetCode", 13L);
  4323.   IO_WriteB(yyf, yyt->U_1.V_42.Rule.HasTargetCode);
  4324.   yyWriteNl();
  4325.   yyWriteSelector((STRING)"HasRejectOrFail", 15L);
  4326.   IO_WriteB(yyf, yyt->U_1.V_42.Rule.HasRejectOrFail);
  4327.   yyWriteNl();
  4328. }
  4329.  
  4330. static void yWriteNodeNoPattern
  4331. # ifdef __STDC__
  4332. (Tree_tTree yyt)
  4333. # else
  4334. (yyt)
  4335. Tree_tTree yyt;
  4336. # endif
  4337. {
  4338.   yyWriteSelector((STRING)"Pos", 3L);
  4339.   Positions_WritePosition(yyf, yyt->U_1.V_44.NoPattern.Pos);
  4340.   yyWriteNl();
  4341. }
  4342.  
  4343. static void yWriteNodeOnePattern
  4344. # ifdef __STDC__
  4345. (Tree_tTree yyt)
  4346. # else
  4347. (yyt)
  4348. Tree_tTree yyt;
  4349. # endif
  4350. {
  4351.   yyWriteSelector((STRING)"Pattern", 7L);
  4352.   yyWriteAdr(yyt->U_1.V_45.OnePattern.Pattern);
  4353.   yyWriteSelector((STRING)"Next", 4L);
  4354.   yyWriteAdr(yyt->U_1.V_45.OnePattern.Next);
  4355. }
  4356.  
  4357. static void yWriteNodeOnePatternsList
  4358. # ifdef __STDC__
  4359. (Tree_tTree yyt)
  4360. # else
  4361. (yyt)
  4362. Tree_tTree yyt;
  4363. # endif
  4364. {
  4365.   yyWriteSelector((STRING)"Patterns", 8L);
  4366.   yyWriteAdr(yyt->U_1.V_48.OnePatternsList.Patterns);
  4367.   yyWriteSelector((STRING)"Next", 4L);
  4368.   yyWriteAdr(yyt->U_1.V_48.OnePatternsList.Next);
  4369. }
  4370.  
  4371. static void yWriteNodePattern
  4372. # ifdef __STDC__
  4373. (Tree_tTree yyt)
  4374. # else
  4375. (yyt)
  4376. Tree_tTree yyt;
  4377. # endif
  4378. {
  4379.   yyWriteSelector((STRING)"Pos", 3L);
  4380.   Positions_WritePosition(yyf, yyt->U_1.V_49.Pattern.Pos);
  4381.   yyWriteNl();
  4382.   yyWriteSelector((STRING)"Tempo", 5L);
  4383.   Idents_WriteIdent(yyf, yyt->U_1.V_49.Pattern.Tempo);
  4384.   yyWriteNl();
  4385.   yyWriteSelector((STRING)"TypeDesc", 8L);
  4386.   yyWriteAdr(yyt->U_1.V_49.Pattern.TypeDesc);
  4387.   yyWriteSelector((STRING)"Path", 4L);
  4388.   yyWriteAdr(yyt->U_1.V_49.Pattern.Path);
  4389. }
  4390.  
  4391. static void yWriteNodeDecompose
  4392. # ifdef __STDC__
  4393. (Tree_tTree yyt)
  4394. # else
  4395. (yyt)
  4396. Tree_tTree yyt;
  4397. # endif
  4398. {
  4399.   yWriteNodePattern(yyt);
  4400.   yyWriteSelector((STRING)"Selector", 8L);
  4401.   Idents_WriteIdent(yyf, yyt->U_1.V_50.Decompose.Selector);
  4402.   yyWriteNl();
  4403.   yyWriteSelector((STRING)"Expr", 4L);
  4404.   yyWriteAdr(yyt->U_1.V_50.Decompose.Expr);
  4405.   yyWriteSelector((STRING)"Patterns", 8L);
  4406.   yyWriteAdr(yyt->U_1.V_50.Decompose.Patterns);
  4407.   yyWriteSelector((STRING)"Widen", 5L);
  4408.   IO_WriteB(yyf, yyt->U_1.V_50.Decompose.Widen);
  4409.   yyWriteNl();
  4410.   yyWriteSelector((STRING)"Object", 6L);
  4411.   yyWriteHex((WORD *)&yyt->U_1.V_50.Decompose.Object, (LONGCARD)sizeof(yyt->U_1.V_50.Decompose.Object));
  4412.   yyWriteNl();
  4413. }
  4414.  
  4415. static void yWriteNodeVarDef
  4416. # ifdef __STDC__
  4417. (Tree_tTree yyt)
  4418. # else
  4419. (yyt)
  4420. Tree_tTree yyt;
  4421. # endif
  4422. {
  4423.   yWriteNodePattern(yyt);
  4424.   yyWriteSelector((STRING)"Name", 4L);
  4425.   Idents_WriteIdent(yyf, yyt->U_1.V_51.VarDef.Name);
  4426.   yyWriteNl();
  4427.   yyWriteSelector((STRING)"Object", 6L);
  4428.   yyWriteHex((WORD *)&yyt->U_1.V_51.VarDef.Object, (LONGCARD)sizeof(yyt->U_1.V_51.VarDef.Object));
  4429.   yyWriteNl();
  4430. }
  4431.  
  4432. static void yWriteNodeNilTest
  4433. # ifdef __STDC__
  4434. (Tree_tTree yyt)
  4435. # else
  4436. (yyt)
  4437. Tree_tTree yyt;
  4438. # endif
  4439. {
  4440.   yWriteNodePattern(yyt);
  4441.   yyWriteSelector((STRING)"Selector", 8L);
  4442.   Idents_WriteIdent(yyf, yyt->U_1.V_52.NilTest.Selector);
  4443.   yyWriteNl();
  4444. }
  4445.  
  4446. static void yWriteNodeDontCare1
  4447. # ifdef __STDC__
  4448. (Tree_tTree yyt)
  4449. # else
  4450. (yyt)
  4451. Tree_tTree yyt;
  4452. # endif
  4453. {
  4454.   yWriteNodePattern(yyt);
  4455. }
  4456.  
  4457. static void yWriteNodeDontCare
  4458. # ifdef __STDC__
  4459. (Tree_tTree yyt)
  4460. # else
  4461. (yyt)
  4462. Tree_tTree yyt;
  4463. # endif
  4464. {
  4465.   yWriteNodePattern(yyt);
  4466.   yyWriteSelector((STRING)"Tempos", 6L);
  4467.   yyWriteAdr(yyt->U_1.V_54.DontCare.Tempos);
  4468. }
  4469.  
  4470. static void yWriteNodeValue
  4471. # ifdef __STDC__
  4472. (Tree_tTree yyt)
  4473. # else
  4474. (yyt)
  4475. Tree_tTree yyt;
  4476. # endif
  4477. {
  4478.   yWriteNodePattern(yyt);
  4479.   yyWriteSelector((STRING)"Expr", 4L);
  4480.   yyWriteAdr(yyt->U_1.V_55.Value.Expr);
  4481. }
  4482.  
  4483. static void yWriteNodeNoExpr
  4484. # ifdef __STDC__
  4485. (Tree_tTree yyt)
  4486. # else
  4487. (yyt)
  4488. Tree_tTree yyt;
  4489. # endif
  4490. {
  4491.   yyWriteSelector((STRING)"Pos", 3L);
  4492.   Positions_WritePosition(yyf, yyt->U_1.V_57.NoExpr.Pos);
  4493.   yyWriteNl();
  4494. }
  4495.  
  4496. static void yWriteNodeOneExpr
  4497. # ifdef __STDC__
  4498. (Tree_tTree yyt)
  4499. # else
  4500. (yyt)
  4501. Tree_tTree yyt;
  4502. # endif
  4503. {
  4504.   yyWriteSelector((STRING)"Expr", 4L);
  4505.   yyWriteAdr(yyt->U_1.V_58.OneExpr.Expr);
  4506.   yyWriteSelector((STRING)"Next", 4L);
  4507.   yyWriteAdr(yyt->U_1.V_58.OneExpr.Next);
  4508. }
  4509.  
  4510. static void yWriteNodeNamedExpr
  4511. # ifdef __STDC__
  4512. (Tree_tTree yyt)
  4513. # else
  4514. (yyt)
  4515. Tree_tTree yyt;
  4516. # endif
  4517. {
  4518.   yWriteNodeOneExpr(yyt);
  4519.   yyWriteSelector((STRING)"Name", 4L);
  4520.   Idents_WriteIdent(yyf, yyt->U_1.V_59.NamedExpr.Name);
  4521.   yyWriteNl();
  4522. }
  4523.  
  4524. static void yWriteNodeExpr
  4525. # ifdef __STDC__
  4526. (Tree_tTree yyt)
  4527. # else
  4528. (yyt)
  4529. Tree_tTree yyt;
  4530. # endif
  4531. {
  4532.   yyWriteSelector((STRING)"Pos", 3L);
  4533.   Positions_WritePosition(yyf, yyt->U_1.V_60.Expr.Pos);
  4534.   yyWriteNl();
  4535. }
  4536.  
  4537. static void yWriteNodeCompose
  4538. # ifdef __STDC__
  4539. (Tree_tTree yyt)
  4540. # else
  4541. (yyt)
  4542. Tree_tTree yyt;
  4543. # endif
  4544. {
  4545.   yWriteNodeExpr(yyt);
  4546.   yyWriteSelector((STRING)"Selector", 8L);
  4547.   Idents_WriteIdent(yyf, yyt->U_1.V_61.Compose.Selector);
  4548.   yyWriteNl();
  4549.   yyWriteSelector((STRING)"Expr", 4L);
  4550.   yyWriteAdr(yyt->U_1.V_61.Compose.Expr);
  4551.   yyWriteSelector((STRING)"Exprs", 5L);
  4552.   yyWriteAdr(yyt->U_1.V_61.Compose.Exprs);
  4553.   yyWriteSelector((STRING)"Widen", 5L);
  4554.   IO_WriteB(yyf, yyt->U_1.V_61.Compose.Widen);
  4555.   yyWriteNl();
  4556.   yyWriteSelector((STRING)"Object", 6L);
  4557.   yyWriteHex((WORD *)&yyt->U_1.V_61.Compose.Object, (LONGCARD)sizeof(yyt->U_1.V_61.Compose.Object));
  4558.   yyWriteNl();
  4559.   yyWriteSelector((STRING)"Tempo", 5L);
  4560.   Idents_WriteIdent(yyf, yyt->U_1.V_61.Compose.Tempo);
  4561.   yyWriteNl();
  4562.   yyWriteSelector((STRING)"TypeDesc", 8L);
  4563.   yyWriteAdr(yyt->U_1.V_61.Compose.TypeDesc);
  4564. }
  4565.  
  4566. static void yWriteNodeVarUse
  4567. # ifdef __STDC__
  4568. (Tree_tTree yyt)
  4569. # else
  4570. (yyt)
  4571. Tree_tTree yyt;
  4572. # endif
  4573. {
  4574.   yWriteNodeExpr(yyt);
  4575.   yyWriteSelector((STRING)"Name", 4L);
  4576.   Idents_WriteIdent(yyf, yyt->U_1.V_62.VarUse.Name);
  4577.   yyWriteNl();
  4578.   yyWriteSelector((STRING)"Object", 6L);
  4579.   yyWriteHex((WORD *)&yyt->U_1.V_62.VarUse.Object, (LONGCARD)sizeof(yyt->U_1.V_62.VarUse.Object));
  4580.   yyWriteNl();
  4581. }
  4582.  
  4583. static void yWriteNodeAttrDesc
  4584. # ifdef __STDC__
  4585. (Tree_tTree yyt)
  4586. # else
  4587. (yyt)
  4588. Tree_tTree yyt;
  4589. # endif
  4590. {
  4591.   yWriteNodeVarUse(yyt);
  4592.   yyWriteSelector((STRING)"Attribute", 9L);
  4593.   Idents_WriteIdent(yyf, yyt->U_1.V_63.AttrDesc.Attribute);
  4594.   yyWriteNl();
  4595.   yyWriteSelector((STRING)"Type", 4L);
  4596.   Idents_WriteIdent(yyf, yyt->U_1.V_63.AttrDesc.Type);
  4597.   yyWriteNl();
  4598. }
  4599.  
  4600. static void yWriteNodeNil
  4601. # ifdef __STDC__
  4602. (Tree_tTree yyt)
  4603. # else
  4604. (yyt)
  4605. Tree_tTree yyt;
  4606. # endif
  4607. {
  4608.   yWriteNodeExpr(yyt);
  4609.   yyWriteSelector((STRING)"Selector", 8L);
  4610.   Idents_WriteIdent(yyf, yyt->U_1.V_64.Nil.Selector);
  4611.   yyWriteNl();
  4612. }
  4613.  
  4614. static void yWriteNodeCall
  4615. # ifdef __STDC__
  4616. (Tree_tTree yyt)
  4617. # else
  4618. (yyt)
  4619. Tree_tTree yyt;
  4620. # endif
  4621. {
  4622.   yWriteNodeExpr(yyt);
  4623.   yyWriteSelector((STRING)"Expr", 4L);
  4624.   yyWriteAdr(yyt->U_1.V_65.Call.Expr);
  4625.   yyWriteSelector((STRING)"Exprs", 5L);
  4626.   yyWriteAdr(yyt->U_1.V_65.Call.Exprs);
  4627.   yyWriteSelector((STRING)"Patterns", 8L);
  4628.   yyWriteAdr(yyt->U_1.V_65.Call.Patterns);
  4629.   yyWriteSelector((STRING)"Object", 6L);
  4630.   yyWriteHex((WORD *)&yyt->U_1.V_65.Call.Object, (LONGCARD)sizeof(yyt->U_1.V_65.Call.Object));
  4631.   yyWriteNl();
  4632. }
  4633.  
  4634. static void yWriteNodeBinary
  4635. # ifdef __STDC__
  4636. (Tree_tTree yyt)
  4637. # else
  4638. (yyt)
  4639. Tree_tTree yyt;
  4640. # endif
  4641. {
  4642.   yWriteNodeExpr(yyt);
  4643.   yyWriteSelector((STRING)"Lop", 3L);
  4644.   yyWriteAdr(yyt->U_1.V_66.Binary.Lop);
  4645.   yyWriteSelector((STRING)"Operator", 8L);
  4646.   Idents_WriteIdent(yyf, yyt->U_1.V_66.Binary.Operator);
  4647.   yyWriteNl();
  4648.   yyWriteSelector((STRING)"Rop", 3L);
  4649.   yyWriteAdr(yyt->U_1.V_66.Binary.Rop);
  4650. }
  4651.  
  4652. static void yWriteNodePreOperator
  4653. # ifdef __STDC__
  4654. (Tree_tTree yyt)
  4655. # else
  4656. (yyt)
  4657. Tree_tTree yyt;
  4658. # endif
  4659. {
  4660.   yWriteNodeExpr(yyt);
  4661.   yyWriteSelector((STRING)"Operator", 8L);
  4662.   Idents_WriteIdent(yyf, yyt->U_1.V_67.PreOperator.Operator);
  4663.   yyWriteNl();
  4664.   yyWriteSelector((STRING)"Expr", 4L);
  4665.   yyWriteAdr(yyt->U_1.V_67.PreOperator.Expr);
  4666. }
  4667.  
  4668. static void yWriteNodePostOperator
  4669. # ifdef __STDC__
  4670. (Tree_tTree yyt)
  4671. # else
  4672. (yyt)
  4673. Tree_tTree yyt;
  4674. # endif
  4675. {
  4676.   yWriteNodeExpr(yyt);
  4677.   yyWriteSelector((STRING)"Operator", 8L);
  4678.   Idents_WriteIdent(yyf, yyt->U_1.V_68.PostOperator.Operator);
  4679.   yyWriteNl();
  4680.   yyWriteSelector((STRING)"Expr", 4L);
  4681.   yyWriteAdr(yyt->U_1.V_68.PostOperator.Expr);
  4682. }
  4683.  
  4684. static void yWriteNodeIndex
  4685. # ifdef __STDC__
  4686. (Tree_tTree yyt)
  4687. # else
  4688. (yyt)
  4689. Tree_tTree yyt;
  4690. # endif
  4691. {
  4692.   yWriteNodeExpr(yyt);
  4693.   yyWriteSelector((STRING)"Expr", 4L);
  4694.   yyWriteAdr(yyt->U_1.V_69.Index.Expr);
  4695.   yyWriteSelector((STRING)"Exprs", 5L);
  4696.   yyWriteAdr(yyt->U_1.V_69.Index.Exprs);
  4697. }
  4698.  
  4699. static void yWriteNodeParents
  4700. # ifdef __STDC__
  4701. (Tree_tTree yyt)
  4702. # else
  4703. (yyt)
  4704. Tree_tTree yyt;
  4705. # endif
  4706. {
  4707.   yWriteNodeExpr(yyt);
  4708.   yyWriteSelector((STRING)"Expr", 4L);
  4709.   yyWriteAdr(yyt->U_1.V_70.Parents.Expr);
  4710. }
  4711.  
  4712. static void yWriteNodeTargetExpr
  4713. # ifdef __STDC__
  4714. (Tree_tTree yyt)
  4715. # else
  4716. (yyt)
  4717. Tree_tTree yyt;
  4718. # endif
  4719. {
  4720.   yWriteNodeExpr(yyt);
  4721.   yyWriteSelector((STRING)"Expr", 4L);
  4722.   yyWriteAdr(yyt->U_1.V_71.TargetExpr.Expr);
  4723.   yyWriteSelector((STRING)"UsedNames", 9L);
  4724.   Sets_WriteSet(yyf, yyt->U_1.V_71.TargetExpr.UsedNames);
  4725.   yyWriteNl();
  4726. }
  4727.  
  4728. static void yWriteNodeStringExpr
  4729. # ifdef __STDC__
  4730. (Tree_tTree yyt)
  4731. # else
  4732. (yyt)
  4733. Tree_tTree yyt;
  4734. # endif
  4735. {
  4736.   yWriteNodeExpr(yyt);
  4737.   yyWriteSelector((STRING)"String", 6L);
  4738.   StringMem_WriteString(yyf, yyt->U_1.V_72.StringExpr.String);
  4739.   yyWriteNl();
  4740. }
  4741.  
  4742. static void yWriteNodeStatement
  4743. # ifdef __STDC__
  4744. (Tree_tTree yyt)
  4745. # else
  4746. (yyt)
  4747. Tree_tTree yyt;
  4748. # endif
  4749. {
  4750.   yyWriteSelector((STRING)"Pos", 3L);
  4751.   Positions_WritePosition(yyf, yyt->U_1.V_75.Statement.Pos);
  4752.   yyWriteNl();
  4753.   yyWriteSelector((STRING)"Next", 4L);
  4754.   yyWriteAdr(yyt->U_1.V_75.Statement.Next);
  4755. }
  4756.  
  4757. static void yWriteNodeProcCall
  4758. # ifdef __STDC__
  4759. (Tree_tTree yyt)
  4760. # else
  4761. (yyt)
  4762. Tree_tTree yyt;
  4763. # endif
  4764. {
  4765.   yWriteNodeStatement(yyt);
  4766.   yyWriteSelector((STRING)"Call", 4L);
  4767.   yyWriteAdr(yyt->U_1.V_76.ProcCall.Call);
  4768. }
  4769.  
  4770. static void yWriteNodeCondition
  4771. # ifdef __STDC__
  4772. (Tree_tTree yyt)
  4773. # else
  4774. (yyt)
  4775. Tree_tTree yyt;
  4776. # endif
  4777. {
  4778.   yWriteNodeStatement(yyt);
  4779.   yyWriteSelector((STRING)"Expr", 4L);
  4780.   yyWriteAdr(yyt->U_1.V_77.Condition.Expr);
  4781. }
  4782.  
  4783. static void yWriteNodeAssignment
  4784. # ifdef __STDC__
  4785. (Tree_tTree yyt)
  4786. # else
  4787. (yyt)
  4788. Tree_tTree yyt;
  4789. # endif
  4790. {
  4791.   yWriteNodeStatement(yyt);
  4792.   yyWriteSelector((STRING)"Adr", 3L);
  4793.   yyWriteAdr(yyt->U_1.V_78.Assignment.Adr);
  4794.   yyWriteSelector((STRING)"Expr", 4L);
  4795.   yyWriteAdr(yyt->U_1.V_78.Assignment.Expr);
  4796.   yyWriteSelector((STRING)"Object", 6L);
  4797.   yyWriteHex((WORD *)&yyt->U_1.V_78.Assignment.Object, (LONGCARD)sizeof(yyt->U_1.V_78.Assignment.Object));
  4798.   yyWriteNl();
  4799. }
  4800.  
  4801. static void yWriteNodeReject
  4802. # ifdef __STDC__
  4803. (Tree_tTree yyt)
  4804. # else
  4805. (yyt)
  4806. Tree_tTree yyt;
  4807. # endif
  4808. {
  4809.   yWriteNodeStatement(yyt);
  4810. }
  4811.  
  4812. static void yWriteNodeFail
  4813. # ifdef __STDC__
  4814. (Tree_tTree yyt)
  4815. # else
  4816. (yyt)
  4817. Tree_tTree yyt;
  4818. # endif
  4819. {
  4820.   yWriteNodeStatement(yyt);
  4821. }
  4822.  
  4823. static void yWriteNodeTargetStmt
  4824. # ifdef __STDC__
  4825. (Tree_tTree yyt)
  4826. # else
  4827. (yyt)
  4828. Tree_tTree yyt;
  4829. # endif
  4830. {
  4831.   yWriteNodeStatement(yyt);
  4832.   yyWriteSelector((STRING)"Parameters", 10L);
  4833.   yyWriteAdr(yyt->U_1.V_81.TargetStmt.Parameters);
  4834.   yyWriteSelector((STRING)"Stmt", 4L);
  4835.   yyWriteAdr(yyt->U_1.V_81.TargetStmt.Stmt);
  4836.   yyWriteSelector((STRING)"UsedNames", 9L);
  4837.   Sets_WriteSet(yyf, yyt->U_1.V_81.TargetStmt.UsedNames);
  4838.   yyWriteNl();
  4839. }
  4840.  
  4841. static void yWriteNodeNl
  4842. # ifdef __STDC__
  4843. (Tree_tTree yyt)
  4844. # else
  4845. (yyt)
  4846. Tree_tTree yyt;
  4847. # endif
  4848. {
  4849.   yWriteNodeStatement(yyt);
  4850. }
  4851.  
  4852. static void yWriteNodeWriteStr
  4853. # ifdef __STDC__
  4854. (Tree_tTree yyt)
  4855. # else
  4856. (yyt)
  4857. Tree_tTree yyt;
  4858. # endif
  4859. {
  4860.   yWriteNodeStatement(yyt);
  4861.   yyWriteSelector((STRING)"String", 6L);
  4862.   StringMem_WriteString(yyf, yyt->U_1.V_83.WriteStr.String);
  4863.   yyWriteNl();
  4864. }
  4865.  
  4866. static void yWriteNodeFormal
  4867. # ifdef __STDC__
  4868. (Tree_tTree yyt)
  4869. # else
  4870. (yyt)
  4871. Tree_tTree yyt;
  4872. # endif
  4873. {
  4874.   yyWriteSelector((STRING)"Next", 4L);
  4875.   yyWriteAdr(yyt->U_1.V_86.Formal.Next);
  4876.   yyWriteSelector((STRING)"Name", 4L);
  4877.   Idents_WriteIdent(yyf, yyt->U_1.V_86.Formal.Name);
  4878.   yyWriteNl();
  4879.   yyWriteSelector((STRING)"TypeDesc", 8L);
  4880.   yyWriteAdr(yyt->U_1.V_86.Formal.TypeDesc);
  4881.   yyWriteSelector((STRING)"Path", 4L);
  4882.   yyWriteAdr(yyt->U_1.V_86.Formal.Path);
  4883. }
  4884.  
  4885. static void yWriteNodeDummyFormal
  4886. # ifdef __STDC__
  4887. (Tree_tTree yyt)
  4888. # else
  4889. (yyt)
  4890. Tree_tTree yyt;
  4891. # endif
  4892. {
  4893.   yyWriteSelector((STRING)"Next", 4L);
  4894.   yyWriteAdr(yyt->U_1.V_87.DummyFormal.Next);
  4895. }
  4896.  
  4897. static void yWriteNodeNodeTypes
  4898. # ifdef __STDC__
  4899. (Tree_tTree yyt)
  4900. # else
  4901. (yyt)
  4902. Tree_tTree yyt;
  4903. # endif
  4904. {
  4905.   yyWriteSelector((STRING)"TreeName", 8L);
  4906.   yyWriteAdr(yyt->U_1.V_89.NodeTypes.TreeName);
  4907.   yyWriteSelector((STRING)"Types", 5L);
  4908.   Sets_WriteSet(yyf, yyt->U_1.V_89.NodeTypes.Types);
  4909.   yyWriteNl();
  4910. }
  4911.  
  4912. static void yWriteNodeUserType
  4913. # ifdef __STDC__
  4914. (Tree_tTree yyt)
  4915. # else
  4916. (yyt)
  4917. Tree_tTree yyt;
  4918. # endif
  4919. {
  4920.   yyWriteSelector((STRING)"Type", 4L);
  4921.   Idents_WriteIdent(yyf, yyt->U_1.V_90.UserType.Type);
  4922.   yyWriteNl();
  4923. }
  4924.  
  4925. static void yWriteNodeVar
  4926. # ifdef __STDC__
  4927. (Tree_tTree yyt)
  4928. # else
  4929. (yyt)
  4930. Tree_tTree yyt;
  4931. # endif
  4932. {
  4933.   yyWriteSelector((STRING)"Name", 4L);
  4934.   Idents_WriteIdent(yyf, yyt->U_1.V_92.Var.Name);
  4935.   yyWriteNl();
  4936.   yyWriteSelector((STRING)"IsOutput", 8L);
  4937.   IO_WriteB(yyf, yyt->U_1.V_92.Var.IsOutput);
  4938.   yyWriteNl();
  4939.   yyWriteSelector((STRING)"IsRegister", 10L);
  4940.   IO_WriteB(yyf, yyt->U_1.V_92.Var.IsRegister);
  4941.   yyWriteNl();
  4942. }
  4943.  
  4944. static void yWriteNodeConsType
  4945. # ifdef __STDC__
  4946. (Tree_tTree yyt)
  4947. # else
  4948. (yyt)
  4949. Tree_tTree yyt;
  4950. # endif
  4951. {
  4952.   yyWriteSelector((STRING)"Next", 4L);
  4953.   yyWriteAdr(yyt->U_1.V_93.ConsType.Next);
  4954.   yyWriteSelector((STRING)"Name", 4L);
  4955.   Idents_WriteIdent(yyf, yyt->U_1.V_93.ConsType.Name);
  4956.   yyWriteNl();
  4957. }
  4958.  
  4959. static void yWriteNodeField
  4960. # ifdef __STDC__
  4961. (Tree_tTree yyt)
  4962. # else
  4963. (yyt)
  4964. Tree_tTree yyt;
  4965. # endif
  4966. {
  4967.   yyWriteSelector((STRING)"Next", 4L);
  4968.   yyWriteAdr(yyt->U_1.V_94.Field.Next);
  4969.   yyWriteSelector((STRING)"Name", 4L);
  4970.   Idents_WriteIdent(yyf, yyt->U_1.V_94.Field.Name);
  4971.   yyWriteNl();
  4972. }
  4973.  
  4974. static void yWriteNodeOneTest
  4975. # ifdef __STDC__
  4976. (Tree_tTree yyt)
  4977. # else
  4978. (yyt)
  4979. Tree_tTree yyt;
  4980. # endif
  4981. {
  4982.   yyWriteSelector((STRING)"Next", 4L);
  4983.   yyWriteAdr(yyt->U_1.V_97.OneTest.Next);
  4984.   yyWriteSelector((STRING)"Path", 4L);
  4985.   yyWriteAdr(yyt->U_1.V_97.OneTest.Path);
  4986. }
  4987.  
  4988. static void yWriteNodeTestKind
  4989. # ifdef __STDC__
  4990. (Tree_tTree yyt)
  4991. # else
  4992. (yyt)
  4993. Tree_tTree yyt;
  4994. # endif
  4995. {
  4996.   yWriteNodeOneTest(yyt);
  4997.   yyWriteSelector((STRING)"TypeDesc", 8L);
  4998.   yyWriteAdr(yyt->U_1.V_98.TestKind.TypeDesc);
  4999.   yyWriteSelector((STRING)"Name", 4L);
  5000.   Idents_WriteIdent(yyf, yyt->U_1.V_98.TestKind.Name);
  5001.   yyWriteNl();
  5002. }
  5003.  
  5004. static void yWriteNodeTestIsType
  5005. # ifdef __STDC__
  5006. (Tree_tTree yyt)
  5007. # else
  5008. (yyt)
  5009. Tree_tTree yyt;
  5010. # endif
  5011. {
  5012.   yWriteNodeOneTest(yyt);
  5013.   yyWriteSelector((STRING)"TypeDesc", 8L);
  5014.   yyWriteAdr(yyt->U_1.V_99.TestIsType.TypeDesc);
  5015.   yyWriteSelector((STRING)"Name", 4L);
  5016.   Idents_WriteIdent(yyf, yyt->U_1.V_99.TestIsType.Name);
  5017.   yyWriteNl();
  5018. }
  5019.  
  5020. static void yWriteNodeTestNil
  5021. # ifdef __STDC__
  5022. (Tree_tTree yyt)
  5023. # else
  5024. (yyt)
  5025. Tree_tTree yyt;
  5026. # endif
  5027. {
  5028.   yWriteNodeOneTest(yyt);
  5029. }
  5030.  
  5031. static void yWriteNodeTestNonlin
  5032. # ifdef __STDC__
  5033. (Tree_tTree yyt)
  5034. # else
  5035. (yyt)
  5036. Tree_tTree yyt;
  5037. # endif
  5038. {
  5039.   yWriteNodeOneTest(yyt);
  5040.   yyWriteSelector((STRING)"Path2", 5L);
  5041.   yyWriteAdr(yyt->U_1.V_101.TestNonlin.Path2);
  5042.   yyWriteSelector((STRING)"TypeDesc", 8L);
  5043.   yyWriteAdr(yyt->U_1.V_101.TestNonlin.TypeDesc);
  5044. }
  5045.  
  5046. static void yWriteNodeTestValue
  5047. # ifdef __STDC__
  5048. (Tree_tTree yyt)
  5049. # else
  5050. (yyt)
  5051. Tree_tTree yyt;
  5052. # endif
  5053. {
  5054.   yWriteNodeOneTest(yyt);
  5055.   yyWriteSelector((STRING)"Expr", 4L);
  5056.   yyWriteAdr(yyt->U_1.V_102.TestValue.Expr);
  5057.   yyWriteSelector((STRING)"TypeDesc", 8L);
  5058.   yyWriteAdr(yyt->U_1.V_102.TestValue.TypeDesc);
  5059. }
  5060.  
  5061. static void yWriteNodeDecision
  5062. # ifdef __STDC__
  5063. (Tree_tTree yyt)
  5064. # else
  5065. (yyt)
  5066. Tree_tTree yyt;
  5067. # endif
  5068. {
  5069.   yyWriteSelector((STRING)"Then", 4L);
  5070.   yyWriteAdr(yyt->U_1.V_105.Decision.Then);
  5071.   yyWriteSelector((STRING)"Else", 4L);
  5072.   yyWriteAdr(yyt->U_1.V_105.Decision.Else);
  5073.   yyWriteSelector((STRING)"OneTest", 7L);
  5074.   yyWriteAdr(yyt->U_1.V_105.Decision.OneTest);
  5075.   yyWriteSelector((STRING)"Cases", 5L);
  5076.   IO_WriteI(yyf, (LONGINT)yyt->U_1.V_105.Decision.Cases, 0L);
  5077.   yyWriteNl();
  5078.   yyWriteSelector((STRING)"IsUnchanged", 11L);
  5079.   IO_WriteB(yyf, yyt->U_1.V_105.Decision.IsUnchanged);
  5080.   yyWriteNl();
  5081. }
  5082.  
  5083. static void yWriteNodeDecided
  5084. # ifdef __STDC__
  5085. (Tree_tTree yyt)
  5086. # else
  5087. (yyt)
  5088. Tree_tTree yyt;
  5089. # endif
  5090. {
  5091.   yyWriteSelector((STRING)"Else", 4L);
  5092.   yyWriteAdr(yyt->U_1.V_106.Decided.Else);
  5093.   yyWriteSelector((STRING)"Rule", 4L);
  5094.   yyWriteAdr(yyt->U_1.V_106.Decided.Rule);
  5095. }
  5096.  
  5097. void Tree_WriteTreeNode
  5098. # ifdef __STDC__
  5099. (IO_tFile yyyf, Tree_tTree yyt)
  5100. # else
  5101. (yyyf, yyt)
  5102. IO_tFile yyyf;
  5103. Tree_tTree yyt;
  5104. # endif
  5105. {
  5106.   yyf = yyyf;
  5107.   if (yyt == Tree_NoTree) {
  5108.     IO_WriteS(yyf, (STRING)"NoTree", 6L);
  5109.     yyWriteNl();
  5110.     return;
  5111.   }
  5112.   switch (yyt->U_1.V_1.Kind) {
  5113.   case Tree_Classes:;
  5114.     IO_WriteS(yyf, (STRING)"Classes", 7L);
  5115.     yyWriteNl();
  5116.     break;
  5117.   case Tree_NoClass:;
  5118.     IO_WriteS(yyf, (STRING)"NoClass", 7L);
  5119.     yyWriteNl();
  5120.     break;
  5121.   case Tree_Class:;
  5122.     IO_WriteS(yyf, (STRING)"Class", 5L);
  5123.     yyWriteNl();
  5124.     yWriteNodeClass(yyt);
  5125.     break;
  5126.   case Tree_Attributes:;
  5127.     IO_WriteS(yyf, (STRING)"Attributes", 10L);
  5128.     yyWriteNl();
  5129.     break;
  5130.   case Tree_NoAttribute:;
  5131.     IO_WriteS(yyf, (STRING)"NoAttribute", 11L);
  5132.     yyWriteNl();
  5133.     break;
  5134.   case Tree_AttrOrAction:;
  5135.     IO_WriteS(yyf, (STRING)"AttrOrAction", 12L);
  5136.     yyWriteNl();
  5137.     yWriteNodeAttrOrAction(yyt);
  5138.     break;
  5139.   case Tree_Child:;
  5140.     IO_WriteS(yyf, (STRING)"Child", 5L);
  5141.     yyWriteNl();
  5142.     yWriteNodeChild(yyt);
  5143.     break;
  5144.   case Tree_Attribute:;
  5145.     IO_WriteS(yyf, (STRING)"Attribute", 9L);
  5146.     yyWriteNl();
  5147.     yWriteNodeAttribute(yyt);
  5148.     break;
  5149.   case Tree_ActionPart:;
  5150.     IO_WriteS(yyf, (STRING)"ActionPart", 10L);
  5151.     yyWriteNl();
  5152.     yWriteNodeActionPart(yyt);
  5153.     break;
  5154.   case Tree_Codes:;
  5155.     IO_WriteS(yyf, (STRING)"Codes", 5L);
  5156.     yyWriteNl();
  5157.     yWriteNodeCodes(yyt);
  5158.     break;
  5159.   case Tree_Designators:;
  5160.     IO_WriteS(yyf, (STRING)"Designators", 11L);
  5161.     yyWriteNl();
  5162.     break;
  5163.   case Tree_NoDesignator:;
  5164.     IO_WriteS(yyf, (STRING)"NoDesignator", 12L);
  5165.     yyWriteNl();
  5166.     break;
  5167.   case Tree_Designator:;
  5168.     IO_WriteS(yyf, (STRING)"Designator", 10L);
  5169.     yyWriteNl();
  5170.     yWriteNodeDesignator(yyt);
  5171.     break;
  5172.   case Tree_Ident:;
  5173.     IO_WriteS(yyf, (STRING)"Ident", 5L);
  5174.     yyWriteNl();
  5175.     yWriteNodeIdent(yyt);
  5176.     break;
  5177.   case Tree_Remote:;
  5178.     IO_WriteS(yyf, (STRING)"Remote", 6L);
  5179.     yyWriteNl();
  5180.     yWriteNodeRemote(yyt);
  5181.     break;
  5182.   case Tree_Any:;
  5183.     IO_WriteS(yyf, (STRING)"Any", 3L);
  5184.     yyWriteNl();
  5185.     yWriteNodeAny(yyt);
  5186.     break;
  5187.   case Tree_Anys:;
  5188.     IO_WriteS(yyf, (STRING)"Anys", 4L);
  5189.     yyWriteNl();
  5190.     yWriteNodeAnys(yyt);
  5191.     break;
  5192.   case Tree_Layouts:;
  5193.     IO_WriteS(yyf, (STRING)"Layouts", 7L);
  5194.     yyWriteNl();
  5195.     break;
  5196.   case Tree_NoLayout:;
  5197.     IO_WriteS(yyf, (STRING)"NoLayout", 8L);
  5198.     yyWriteNl();
  5199.     break;
  5200.   case Tree_LayoutAny:;
  5201.     IO_WriteS(yyf, (STRING)"LayoutAny", 9L);
  5202.     yyWriteNl();
  5203.     yWriteNodeLayoutAny(yyt);
  5204.     break;
  5205.   case Tree_Names:;
  5206.     IO_WriteS(yyf, (STRING)"Names", 5L);
  5207.     yyWriteNl();
  5208.     break;
  5209.   case Tree_NoName:;
  5210.     IO_WriteS(yyf, (STRING)"NoName", 6L);
  5211.     yyWriteNl();
  5212.     break;
  5213.   case Tree_Name:;
  5214.     IO_WriteS(yyf, (STRING)"Name", 4L);
  5215.     yyWriteNl();
  5216.     yWriteNodeName(yyt);
  5217.     break;
  5218.   case Tree_Spec:;
  5219.     IO_WriteS(yyf, (STRING)"Spec", 4L);
  5220.     yyWriteNl();
  5221.     yWriteNodeSpec(yyt);
  5222.     break;
  5223.   case Tree_TreeNames:;
  5224.     IO_WriteS(yyf, (STRING)"TreeNames", 9L);
  5225.     yyWriteNl();
  5226.     break;
  5227.   case Tree_NoTreeName:;
  5228.     IO_WriteS(yyf, (STRING)"NoTreeName", 10L);
  5229.     yyWriteNl();
  5230.     break;
  5231.   case Tree_TreeName:;
  5232.     IO_WriteS(yyf, (STRING)"TreeName", 8L);
  5233.     yyWriteNl();
  5234.     yWriteNodeTreeName(yyt);
  5235.     break;
  5236.   case Tree_Routines:;
  5237.     IO_WriteS(yyf, (STRING)"Routines", 8L);
  5238.     yyWriteNl();
  5239.     break;
  5240.   case Tree_NoRoutine:;
  5241.     IO_WriteS(yyf, (STRING)"NoRoutine", 9L);
  5242.     yyWriteNl();
  5243.     break;
  5244.   case Tree_Routine:;
  5245.     IO_WriteS(yyf, (STRING)"Routine", 7L);
  5246.     yyWriteNl();
  5247.     yWriteNodeRoutine(yyt);
  5248.     break;
  5249.   case Tree_Procedure:;
  5250.     IO_WriteS(yyf, (STRING)"Procedure", 9L);
  5251.     yyWriteNl();
  5252.     yWriteNodeProcedure(yyt);
  5253.     break;
  5254.   case Tree_Function:;
  5255.     IO_WriteS(yyf, (STRING)"Function", 8L);
  5256.     yyWriteNl();
  5257.     yWriteNodeFunction(yyt);
  5258.     break;
  5259.   case Tree_Predicate:;
  5260.     IO_WriteS(yyf, (STRING)"Predicate", 9L);
  5261.     yyWriteNl();
  5262.     yWriteNodePredicate(yyt);
  5263.     break;
  5264.   case Tree_Parameters:;
  5265.     IO_WriteS(yyf, (STRING)"Parameters", 10L);
  5266.     yyWriteNl();
  5267.     break;
  5268.   case Tree_NoParameter:;
  5269.     IO_WriteS(yyf, (STRING)"NoParameter", 11L);
  5270.     yyWriteNl();
  5271.     break;
  5272.   case Tree_Param:;
  5273.     IO_WriteS(yyf, (STRING)"Param", 5L);
  5274.     yyWriteNl();
  5275.     yWriteNodeParam(yyt);
  5276.     break;
  5277.   case Tree_Type:;
  5278.     IO_WriteS(yyf, (STRING)"Type", 4L);
  5279.     yyWriteNl();
  5280.     yWriteNodeType(yyt);
  5281.     break;
  5282.   case Tree_Rules:;
  5283.     IO_WriteS(yyf, (STRING)"Rules", 5L);
  5284.     yyWriteNl();
  5285.     break;
  5286.   case Tree_NoRule:;
  5287.     IO_WriteS(yyf, (STRING)"NoRule", 6L);
  5288.     yyWriteNl();
  5289.     break;
  5290.   case Tree_Rule:;
  5291.     IO_WriteS(yyf, (STRING)"Rule", 4L);
  5292.     yyWriteNl();
  5293.     yWriteNodeRule(yyt);
  5294.     break;
  5295.   case Tree_Patterns:;
  5296.     IO_WriteS(yyf, (STRING)"Patterns", 8L);
  5297.     yyWriteNl();
  5298.     break;
  5299.   case Tree_NoPattern:;
  5300.     IO_WriteS(yyf, (STRING)"NoPattern", 9L);
  5301.     yyWriteNl();
  5302.     yWriteNodeNoPattern(yyt);
  5303.     break;
  5304.   case Tree_OnePattern:;
  5305.     IO_WriteS(yyf, (STRING)"OnePattern", 10L);
  5306.     yyWriteNl();
  5307.     yWriteNodeOnePattern(yyt);
  5308.     break;
  5309.   case Tree_PatternsList:;
  5310.     IO_WriteS(yyf, (STRING)"PatternsList", 12L);
  5311.     yyWriteNl();
  5312.     break;
  5313.   case Tree_NoPatternsList:;
  5314.     IO_WriteS(yyf, (STRING)"NoPatternsList", 14L);
  5315.     yyWriteNl();
  5316.     break;
  5317.   case Tree_OnePatternsList:;
  5318.     IO_WriteS(yyf, (STRING)"OnePatternsList", 15L);
  5319.     yyWriteNl();
  5320.     yWriteNodeOnePatternsList(yyt);
  5321.     break;
  5322.   case Tree_Pattern:;
  5323.     IO_WriteS(yyf, (STRING)"Pattern", 7L);
  5324.     yyWriteNl();
  5325.     yWriteNodePattern(yyt);
  5326.     break;
  5327.   case Tree_Decompose:;
  5328.     IO_WriteS(yyf, (STRING)"Decompose", 9L);
  5329.     yyWriteNl();
  5330.     yWriteNodeDecompose(yyt);
  5331.     break;
  5332.   case Tree_VarDef:;
  5333.     IO_WriteS(yyf, (STRING)"VarDef", 6L);
  5334.     yyWriteNl();
  5335.     yWriteNodeVarDef(yyt);
  5336.     break;
  5337.   case Tree_NilTest:;
  5338.     IO_WriteS(yyf, (STRING)"NilTest", 7L);
  5339.     yyWriteNl();
  5340.     yWriteNodeNilTest(yyt);
  5341.     break;
  5342.   case Tree_DontCare1:;
  5343.     IO_WriteS(yyf, (STRING)"DontCare1", 9L);
  5344.     yyWriteNl();
  5345.     yWriteNodeDontCare1(yyt);
  5346.     break;
  5347.   case Tree_DontCare:;
  5348.     IO_WriteS(yyf, (STRING)"DontCare", 8L);
  5349.     yyWriteNl();
  5350.     yWriteNodeDontCare(yyt);
  5351.     break;
  5352.   case Tree_Value:;
  5353.     IO_WriteS(yyf, (STRING)"Value", 5L);
  5354.     yyWriteNl();
  5355.     yWriteNodeValue(yyt);
  5356.     break;
  5357.   case Tree_Exprs:;
  5358.     IO_WriteS(yyf, (STRING)"Exprs", 5L);
  5359.     yyWriteNl();
  5360.     break;
  5361.   case Tree_NoExpr:;
  5362.     IO_WriteS(yyf, (STRING)"NoExpr", 6L);
  5363.     yyWriteNl();
  5364.     yWriteNodeNoExpr(yyt);
  5365.     break;
  5366.   case Tree_OneExpr:;
  5367.     IO_WriteS(yyf, (STRING)"OneExpr", 7L);
  5368.     yyWriteNl();
  5369.     yWriteNodeOneExpr(yyt);
  5370.     break;
  5371.   case Tree_NamedExpr:;
  5372.     IO_WriteS(yyf, (STRING)"NamedExpr", 9L);
  5373.     yyWriteNl();
  5374.     yWriteNodeNamedExpr(yyt);
  5375.     break;
  5376.   case Tree_Expr:;
  5377.     IO_WriteS(yyf, (STRING)"Expr", 4L);
  5378.     yyWriteNl();
  5379.     yWriteNodeExpr(yyt);
  5380.     break;
  5381.   case Tree_Compose:;
  5382.     IO_WriteS(yyf, (STRING)"Compose", 7L);
  5383.     yyWriteNl();
  5384.     yWriteNodeCompose(yyt);
  5385.     break;
  5386.   case Tree_VarUse:;
  5387.     IO_WriteS(yyf, (STRING)"VarUse", 6L);
  5388.     yyWriteNl();
  5389.     yWriteNodeVarUse(yyt);
  5390.     break;
  5391.   case Tree_AttrDesc:;
  5392.     IO_WriteS(yyf, (STRING)"AttrDesc", 8L);
  5393.     yyWriteNl();
  5394.     yWriteNodeAttrDesc(yyt);
  5395.     break;
  5396.   case Tree_Nil:;
  5397.     IO_WriteS(yyf, (STRING)"Nil", 3L);
  5398.     yyWriteNl();
  5399.     yWriteNodeNil(yyt);
  5400.     break;
  5401.   case Tree_Call:;
  5402.     IO_WriteS(yyf, (STRING)"Call", 4L);
  5403.     yyWriteNl();
  5404.     yWriteNodeCall(yyt);
  5405.     break;
  5406.   case Tree_Binary:;
  5407.     IO_WriteS(yyf, (STRING)"Binary", 6L);
  5408.     yyWriteNl();
  5409.     yWriteNodeBinary(yyt);
  5410.     break;
  5411.   case Tree_PreOperator:;
  5412.     IO_WriteS(yyf, (STRING)"PreOperator", 11L);
  5413.     yyWriteNl();
  5414.     yWriteNodePreOperator(yyt);
  5415.     break;
  5416.   case Tree_PostOperator:;
  5417.     IO_WriteS(yyf, (STRING)"PostOperator", 12L);
  5418.     yyWriteNl();
  5419.     yWriteNodePostOperator(yyt);
  5420.     break;
  5421.   case Tree_Index:;
  5422.     IO_WriteS(yyf, (STRING)"Index", 5L);
  5423.     yyWriteNl();
  5424.     yWriteNodeIndex(yyt);
  5425.     break;
  5426.   case Tree_Parents:;
  5427.     IO_WriteS(yyf, (STRING)"Parents", 7L);
  5428.     yyWriteNl();
  5429.     yWriteNodeParents(yyt);
  5430.     break;
  5431.   case Tree_TargetExpr:;
  5432.     IO_WriteS(yyf, (STRING)"TargetExpr", 10L);
  5433.     yyWriteNl();
  5434.     yWriteNodeTargetExpr(yyt);
  5435.     break;
  5436.   case Tree_StringExpr:;
  5437.     IO_WriteS(yyf, (STRING)"StringExpr", 10L);
  5438.     yyWriteNl();
  5439.     yWriteNodeStringExpr(yyt);
  5440.     break;
  5441.   case Tree_Statements:;
  5442.     IO_WriteS(yyf, (STRING)"Statements", 10L);
  5443.     yyWriteNl();
  5444.     break;
  5445.   case Tree_NoStatement:;
  5446.     IO_WriteS(yyf, (STRING)"NoStatement", 11L);
  5447.     yyWriteNl();
  5448.     break;
  5449.   case Tree_Statement:;
  5450.     IO_WriteS(yyf, (STRING)"Statement", 9L);
  5451.     yyWriteNl();
  5452.     yWriteNodeStatement(yyt);
  5453.     break;
  5454.   case Tree_ProcCall:;
  5455.     IO_WriteS(yyf, (STRING)"ProcCall", 8L);
  5456.     yyWriteNl();
  5457.     yWriteNodeProcCall(yyt);
  5458.     break;
  5459.   case Tree_Condition:;
  5460.     IO_WriteS(yyf, (STRING)"Condition", 9L);
  5461.     yyWriteNl();
  5462.     yWriteNodeCondition(yyt);
  5463.     break;
  5464.   case Tree_Assignment:;
  5465.     IO_WriteS(yyf, (STRING)"Assignment", 10L);
  5466.     yyWriteNl();
  5467.     yWriteNodeAssignment(yyt);
  5468.     break;
  5469.   case Tree_Reject:;
  5470.     IO_WriteS(yyf, (STRING)"Reject", 6L);
  5471.     yyWriteNl();
  5472.     yWriteNodeReject(yyt);
  5473.     break;
  5474.   case Tree_Fail:;
  5475.     IO_WriteS(yyf, (STRING)"Fail", 4L);
  5476.     yyWriteNl();
  5477.     yWriteNodeFail(yyt);
  5478.     break;
  5479.   case Tree_TargetStmt:;
  5480.     IO_WriteS(yyf, (STRING)"TargetStmt", 10L);
  5481.     yyWriteNl();
  5482.     yWriteNodeTargetStmt(yyt);
  5483.     break;
  5484.   case Tree_Nl:;
  5485.     IO_WriteS(yyf, (STRING)"Nl", 2L);
  5486.     yyWriteNl();
  5487.     yWriteNodeNl(yyt);
  5488.     break;
  5489.   case Tree_WriteStr:;
  5490.     IO_WriteS(yyf, (STRING)"WriteStr", 8L);
  5491.     yyWriteNl();
  5492.     yWriteNodeWriteStr(yyt);
  5493.     break;
  5494.   case Tree_Formals:;
  5495.     IO_WriteS(yyf, (STRING)"Formals", 7L);
  5496.     yyWriteNl();
  5497.     break;
  5498.   case Tree_NoFormal:;
  5499.     IO_WriteS(yyf, (STRING)"NoFormal", 8L);
  5500.     yyWriteNl();
  5501.     break;
  5502.   case Tree_Formal:;
  5503.     IO_WriteS(yyf, (STRING)"Formal", 6L);
  5504.     yyWriteNl();
  5505.     yWriteNodeFormal(yyt);
  5506.     break;
  5507.   case Tree_DummyFormal:;
  5508.     IO_WriteS(yyf, (STRING)"DummyFormal", 11L);
  5509.     yyWriteNl();
  5510.     yWriteNodeDummyFormal(yyt);
  5511.     break;
  5512.   case Tree_TypeDesc:;
  5513.     IO_WriteS(yyf, (STRING)"TypeDesc", 8L);
  5514.     yyWriteNl();
  5515.     break;
  5516.   case Tree_NodeTypes:;
  5517.     IO_WriteS(yyf, (STRING)"NodeTypes", 9L);
  5518.     yyWriteNl();
  5519.     yWriteNodeNodeTypes(yyt);
  5520.     break;
  5521.   case Tree_UserType:;
  5522.     IO_WriteS(yyf, (STRING)"UserType", 8L);
  5523.     yyWriteNl();
  5524.     yWriteNodeUserType(yyt);
  5525.     break;
  5526.   case Tree_Path:;
  5527.     IO_WriteS(yyf, (STRING)"Path", 4L);
  5528.     yyWriteNl();
  5529.     break;
  5530.   case Tree_Var:;
  5531.     IO_WriteS(yyf, (STRING)"Var", 3L);
  5532.     yyWriteNl();
  5533.     yWriteNodeVar(yyt);
  5534.     break;
  5535.   case Tree_ConsType:;
  5536.     IO_WriteS(yyf, (STRING)"ConsType", 8L);
  5537.     yyWriteNl();
  5538.     yWriteNodeConsType(yyt);
  5539.     break;
  5540.   case Tree_Field:;
  5541.     IO_WriteS(yyf, (STRING)"Field", 5L);
  5542.     yyWriteNl();
  5543.     yWriteNodeField(yyt);
  5544.     break;
  5545.   case Tree_Tests:;
  5546.     IO_WriteS(yyf, (STRING)"Tests", 5L);
  5547.     yyWriteNl();
  5548.     break;
  5549.   case Tree_NoTest:;
  5550.     IO_WriteS(yyf, (STRING)"NoTest", 6L);
  5551.     yyWriteNl();
  5552.     break;
  5553.   case Tree_OneTest:;
  5554.     IO_WriteS(yyf, (STRING)"OneTest", 7L);
  5555.     yyWriteNl();
  5556.     yWriteNodeOneTest(yyt);
  5557.     break;
  5558.   case Tree_TestKind:;
  5559.     IO_WriteS(yyf, (STRING)"TestKind", 8L);
  5560.     yyWriteNl();
  5561.     yWriteNodeTestKind(yyt);
  5562.     break;
  5563.   case Tree_TestIsType:;
  5564.     IO_WriteS(yyf, (STRING)"TestIsType", 10L);
  5565.     yyWriteNl();
  5566.     yWriteNodeTestIsType(yyt);
  5567.     break;
  5568.   case Tree_TestNil:;
  5569.     IO_WriteS(yyf, (STRING)"TestNil", 7L);
  5570.     yyWriteNl();
  5571.     yWriteNodeTestNil(yyt);
  5572.     break;
  5573.   case Tree_TestNonlin:;
  5574.     IO_WriteS(yyf, (STRING)"TestNonlin", 10L);
  5575.     yyWriteNl();
  5576.     yWriteNodeTestNonlin(yyt);
  5577.     break;
  5578.   case Tree_TestValue:;
  5579.     IO_WriteS(yyf, (STRING)"TestValue", 9L);
  5580.     yyWriteNl();
  5581.     yWriteNodeTestValue(yyt);
  5582.     break;
  5583.   case Tree_Decisions:;
  5584.     IO_WriteS(yyf, (STRING)"Decisions", 9L);
  5585.     yyWriteNl();
  5586.     break;
  5587.   case Tree_NoDecision:;
  5588.     IO_WriteS(yyf, (STRING)"NoDecision", 10L);
  5589.     yyWriteNl();
  5590.     break;
  5591.   case Tree_Decision:;
  5592.     IO_WriteS(yyf, (STRING)"Decision", 8L);
  5593.     yyWriteNl();
  5594.     yWriteNodeDecision(yyt);
  5595.     break;
  5596.   case Tree_Decided:;
  5597.     IO_WriteS(yyf, (STRING)"Decided", 7L);
  5598.     yyWriteNl();
  5599.     yWriteNodeDecided(yyt);
  5600.     break;
  5601.   default :
  5602.     break;
  5603.   }
  5604. }
  5605.  
  5606. Tree_tTree Tree_ReverseTree
  5607. # ifdef __STDC__
  5608. (Tree_tTree yyOld)
  5609. # else
  5610. (yyOld)
  5611. Tree_tTree yyOld;
  5612. # endif
  5613. {
  5614.   Tree_tTree yyNew, yyNext, yyTail;
  5615.  
  5616.   yyNew = yyOld;
  5617.   yyTail = yyOld;
  5618.   for (;;) {
  5619.     switch (yyOld->U_1.V_1.Kind) {
  5620.     case Tree_Class:;
  5621.       yyNext = yyOld->U_1.V_5.Class.Next;
  5622.       yyOld->U_1.V_5.Class.Next = yyNew;
  5623.       break;
  5624.     case Tree_AttrOrAction:;
  5625.       yyNext = yyOld->U_1.V_8.AttrOrAction.Next;
  5626.       yyOld->U_1.V_8.AttrOrAction.Next = yyNew;
  5627.       break;
  5628.     case Tree_Child:;
  5629.       yyNext = yyOld->U_1.V_9.Child.Next;
  5630.       yyOld->U_1.V_9.Child.Next = yyNew;
  5631.       break;
  5632.     case Tree_Attribute:;
  5633.       yyNext = yyOld->U_1.V_10.Attribute.Next;
  5634.       yyOld->U_1.V_10.Attribute.Next = yyNew;
  5635.       break;
  5636.     case Tree_ActionPart:;
  5637.       yyNext = yyOld->U_1.V_11.ActionPart.Next;
  5638.       yyOld->U_1.V_11.ActionPart.Next = yyNew;
  5639.       break;
  5640.     case Tree_Designator:;
  5641.       yyNext = yyOld->U_1.V_15.Designator.Next;
  5642.       yyOld->U_1.V_15.Designator.Next = yyNew;
  5643.       break;
  5644.     case Tree_Ident:;
  5645.       yyNext = yyOld->U_1.V_16.Ident.Next;
  5646.       yyOld->U_1.V_16.Ident.Next = yyNew;
  5647.       break;
  5648.     case Tree_Remote:;
  5649.       yyNext = yyOld->U_1.V_17.Remote.Next;
  5650.       yyOld->U_1.V_17.Remote.Next = yyNew;
  5651.       break;
  5652.     case Tree_Any:;
  5653.       yyNext = yyOld->U_1.V_18.Any.Next;
  5654.       yyOld->U_1.V_18.Any.Next = yyNew;
  5655.       break;
  5656.     case Tree_Anys:;
  5657.       yyNext = yyOld->U_1.V_19.Anys.Next;
  5658.       yyOld->U_1.V_19.Anys.Next = yyNew;
  5659.       break;
  5660.     case Tree_LayoutAny:;
  5661.       yyNext = yyOld->U_1.V_22.LayoutAny.Next;
  5662.       yyOld->U_1.V_22.LayoutAny.Next = yyNew;
  5663.       break;
  5664.     case Tree_Name:;
  5665.       yyNext = yyOld->U_1.V_25.Name.Next;
  5666.       yyOld->U_1.V_25.Name.Next = yyNew;
  5667.       break;
  5668.     case Tree_TreeName:;
  5669.       yyNext = yyOld->U_1.V_29.TreeName.Next;
  5670.       yyOld->U_1.V_29.TreeName.Next = yyNew;
  5671.       break;
  5672.     case Tree_Routine:;
  5673.       yyNext = yyOld->U_1.V_32.Routine.Next;
  5674.       yyOld->U_1.V_32.Routine.Next = yyNew;
  5675.       break;
  5676.     case Tree_Procedure:;
  5677.       yyNext = yyOld->U_1.V_33.Procedure.Next;
  5678.       yyOld->U_1.V_33.Procedure.Next = yyNew;
  5679.       break;
  5680.     case Tree_Function:;
  5681.       yyNext = yyOld->U_1.V_34.Function.Next;
  5682.       yyOld->U_1.V_34.Function.Next = yyNew;
  5683.       break;
  5684.     case Tree_Predicate:;
  5685.       yyNext = yyOld->U_1.V_35.Predicate.Next;
  5686.       yyOld->U_1.V_35.Predicate.Next = yyNew;
  5687.       break;
  5688.     case Tree_Param:;
  5689.       yyNext = yyOld->U_1.V_38.Param.Next;
  5690.       yyOld->U_1.V_38.Param.Next = yyNew;
  5691.       break;
  5692.     case Tree_Rule:;
  5693.       yyNext = yyOld->U_1.V_42.Rule.Next;
  5694.       yyOld->U_1.V_42.Rule.Next = yyNew;
  5695.       break;
  5696.     case Tree_OnePattern:;
  5697.       yyNext = yyOld->U_1.V_45.OnePattern.Next;
  5698.       yyOld->U_1.V_45.OnePattern.Next = yyNew;
  5699.       break;
  5700.     case Tree_OneExpr:;
  5701.       yyNext = yyOld->U_1.V_58.OneExpr.Next;
  5702.       yyOld->U_1.V_58.OneExpr.Next = yyNew;
  5703.       break;
  5704.     case Tree_NamedExpr:;
  5705.       yyNext = yyOld->U_1.V_59.NamedExpr.Next;
  5706.       yyOld->U_1.V_59.NamedExpr.Next = yyNew;
  5707.       break;
  5708.     case Tree_Statement:;
  5709.       yyNext = yyOld->U_1.V_75.Statement.Next;
  5710.       yyOld->U_1.V_75.Statement.Next = yyNew;
  5711.       break;
  5712.     case Tree_ProcCall:;
  5713.       yyNext = yyOld->U_1.V_76.ProcCall.Next;
  5714.       yyOld->U_1.V_76.ProcCall.Next = yyNew;
  5715.       break;
  5716.     case Tree_Condition:;
  5717.       yyNext = yyOld->U_1.V_77.Condition.Next;
  5718.       yyOld->U_1.V_77.Condition.Next = yyNew;
  5719.       break;
  5720.     case Tree_Assignment:;
  5721.       yyNext = yyOld->U_1.V_78.Assignment.Next;
  5722.       yyOld->U_1.V_78.Assignment.Next = yyNew;
  5723.       break;
  5724.     case Tree_Reject:;
  5725.       yyNext = yyOld->U_1.V_79.Reject.Next;
  5726.       yyOld->U_1.V_79.Reject.Next = yyNew;
  5727.       break;
  5728.     case Tree_Fail:;
  5729.       yyNext = yyOld->U_1.V_80.Fail.Next;
  5730.       yyOld->U_1.V_80.Fail.Next = yyNew;
  5731.       break;
  5732.     case Tree_TargetStmt:;
  5733.       yyNext = yyOld->U_1.V_81.TargetStmt.Next;
  5734.       yyOld->U_1.V_81.TargetStmt.Next = yyNew;
  5735.       break;
  5736.     case Tree_Nl:;
  5737.       yyNext = yyOld->U_1.V_82.Nl.Next;
  5738.       yyOld->U_1.V_82.Nl.Next = yyNew;
  5739.       break;
  5740.     case Tree_WriteStr:;
  5741.       yyNext = yyOld->U_1.V_83.WriteStr.Next;
  5742.       yyOld->U_1.V_83.WriteStr.Next = yyNew;
  5743.       break;
  5744.     case Tree_Formal:;
  5745.       yyNext = yyOld->U_1.V_86.Formal.Next;
  5746.       yyOld->U_1.V_86.Formal.Next = yyNew;
  5747.       break;
  5748.     default :
  5749.       goto EXIT_4;
  5750.       break;
  5751.     }
  5752.     yyNew = yyOld;
  5753.     yyOld = yyNext;
  5754.   } EXIT_4:;
  5755.   switch (yyTail->U_1.V_1.Kind) {
  5756.   case Tree_Class:;
  5757.     yyTail->U_1.V_5.Class.Next = yyOld;
  5758.     break;
  5759.   case Tree_AttrOrAction:;
  5760.     yyTail->U_1.V_8.AttrOrAction.Next = yyOld;
  5761.     break;
  5762.   case Tree_Child:;
  5763.     yyTail->U_1.V_9.Child.Next = yyOld;
  5764.     break;
  5765.   case Tree_Attribute:;
  5766.     yyTail->U_1.V_10.Attribute.Next = yyOld;
  5767.     break;
  5768.   case Tree_ActionPart:;
  5769.     yyTail->U_1.V_11.ActionPart.Next = yyOld;
  5770.     break;
  5771.   case Tree_Designator:;
  5772.     yyTail->U_1.V_15.Designator.Next = yyOld;
  5773.     break;
  5774.   case Tree_Ident:;
  5775.     yyTail->U_1.V_16.Ident.Next = yyOld;
  5776.     break;
  5777.   case Tree_Remote:;
  5778.     yyTail->U_1.V_17.Remote.Next = yyOld;
  5779.     break;
  5780.   case Tree_Any:;
  5781.     yyTail->U_1.V_18.Any.Next = yyOld;
  5782.     break;
  5783.   case Tree_Anys:;
  5784.     yyTail->U_1.V_19.Anys.Next = yyOld;
  5785.     break;
  5786.   case Tree_LayoutAny:;
  5787.     yyTail->U_1.V_22.LayoutAny.Next = yyOld;
  5788.     break;
  5789.   case Tree_Name:;
  5790.     yyTail->U_1.V_25.Name.Next = yyOld;
  5791.     break;
  5792.   case Tree_TreeName:;
  5793.     yyTail->U_1.V_29.TreeName.Next = yyOld;
  5794.     break;
  5795.   case Tree_Routine:;
  5796.     yyTail->U_1.V_32.Routine.Next = yyOld;
  5797.     break;
  5798.   case Tree_Procedure:;
  5799.     yyTail->U_1.V_33.Procedure.Next = yyOld;
  5800.     break;
  5801.   case Tree_Function:;
  5802.     yyTail->U_1.V_34.Function.Next = yyOld;
  5803.     break;
  5804.   case Tree_Predicate:;
  5805.     yyTail->U_1.V_35.Predicate.Next = yyOld;
  5806.     break;
  5807.   case Tree_Param:;
  5808.     yyTail->U_1.V_38.Param.Next = yyOld;
  5809.     break;
  5810.   case Tree_Rule:;
  5811.     yyTail->U_1.V_42.Rule.Next = yyOld;
  5812.     break;
  5813.   case Tree_OnePattern:;
  5814.     yyTail->U_1.V_45.OnePattern.Next = yyOld;
  5815.     break;
  5816.   case Tree_OneExpr:;
  5817.     yyTail->U_1.V_58.OneExpr.Next = yyOld;
  5818.     break;
  5819.   case Tree_NamedExpr:;
  5820.     yyTail->U_1.V_59.NamedExpr.Next = yyOld;
  5821.     break;
  5822.   case Tree_Statement:;
  5823.     yyTail->U_1.V_75.Statement.Next = yyOld;
  5824.     break;
  5825.   case Tree_ProcCall:;
  5826.     yyTail->U_1.V_76.ProcCall.Next = yyOld;
  5827.     break;
  5828.   case Tree_Condition:;
  5829.     yyTail->U_1.V_77.Condition.Next = yyOld;
  5830.     break;
  5831.   case Tree_Assignment:;
  5832.     yyTail->U_1.V_78.Assignment.Next = yyOld;
  5833.     break;
  5834.   case Tree_Reject:;
  5835.     yyTail->U_1.V_79.Reject.Next = yyOld;
  5836.     break;
  5837.   case Tree_Fail:;
  5838.     yyTail->U_1.V_80.Fail.Next = yyOld;
  5839.     break;
  5840.   case Tree_TargetStmt:;
  5841.     yyTail->U_1.V_81.TargetStmt.Next = yyOld;
  5842.     break;
  5843.   case Tree_Nl:;
  5844.     yyTail->U_1.V_82.Nl.Next = yyOld;
  5845.     break;
  5846.   case Tree_WriteStr:;
  5847.     yyTail->U_1.V_83.WriteStr.Next = yyOld;
  5848.     break;
  5849.   case Tree_Formal:;
  5850.     yyTail->U_1.V_86.Formal.Next = yyOld;
  5851.     break;
  5852.   default :
  5853.     break;
  5854.   }
  5855.   return yyNew;
  5856. }
  5857.  
  5858. static void yyStoreOldToNew
  5859. # ifdef __STDC__
  5860. (Tree_tTree yyOld, Tree_tTree yyNew)
  5861. # else
  5862. (yyOld, yyNew)
  5863. Tree_tTree yyOld, yyNew;
  5864. # endif
  5865. {
  5866.   INC(yyOldToNewCount);
  5867.   if (yyOldToNewCount == yyOldToNewStoreSize) {
  5868.     DynArray_ExtendArray((ADDRESS *)&yyOldToNewStorePtr, &yyOldToNewStoreSize, (LONGINT)sizeof(yytOldToNew));
  5869.   }
  5870.   yyOldToNewStorePtr->A[yyOldToNewCount].yyOld = yyOld;
  5871.   yyOldToNewStorePtr->A[yyOldToNewCount].yyNew = yyNew;
  5872. }
  5873.  
  5874. static Tree_tTree yyMapOldToNew
  5875. # ifdef __STDC__
  5876. (Tree_tTree yyOld)
  5877. # else
  5878. (yyOld)
  5879. Tree_tTree yyOld;
  5880. # endif
  5881. {
  5882.   INTEGER yyi;
  5883.  
  5884.   {
  5885.     LONGINT B_7 = 1, B_8 = yyOldToNewCount;
  5886.  
  5887.     if (B_7 <= B_8)
  5888.       for (yyi = B_7;; yyi += 1) {
  5889.         if (yyOldToNewStorePtr->A[yyi].yyOld == yyOld) {
  5890.           return yyOldToNewStorePtr->A[yyi].yyNew;
  5891.         }
  5892.         if (yyi >= B_8) break;
  5893.       }
  5894.   }
  5895. }
  5896.  
  5897. static void yyCopyTree
  5898. # ifdef __STDC__
  5899. (Tree_tTree yyt, yyPtrtTree yyNew)
  5900. # else
  5901. (yyt, yyNew)
  5902. Tree_tTree yyt;
  5903. yyPtrtTree yyNew;
  5904. # endif
  5905. {
  5906.   for (;;) {
  5907.     if (yyt == Tree_NoTree) {
  5908.       *yyNew = Tree_NoTree;
  5909.       return;
  5910.     }
  5911.     if (yyt->U_1.V_2.yyHead.yyMark == 0) {
  5912.       *yyNew = yyMapOldToNew(yyt);
  5913.       return;
  5914.     }
  5915.     *yyNew = Tree_MakeTree(yyt->U_1.V_1.Kind);
  5916.     if (yyt->U_1.V_2.yyHead.yyMark > 1) {
  5917.       yyStoreOldToNew(yyt, *yyNew);
  5918.     }
  5919.     yyt->U_1.V_2.yyHead.yyMark = 0;
  5920.     switch (yyt->U_1.V_1.Kind) {
  5921.     case Tree_Classes:;
  5922.       (*yyNew)->U_1.V_3.Classes = yyt->U_1.V_3.Classes;
  5923.       return;
  5924.       break;
  5925.     case Tree_NoClass:;
  5926.       (*yyNew)->U_1.V_4.NoClass = yyt->U_1.V_4.NoClass;
  5927.       return;
  5928.       break;
  5929.     case Tree_Class:;
  5930.       (*yyNew)->U_1.V_5.Class = yyt->U_1.V_5.Class;
  5931.       yyCopyTree(yyt->U_1.V_5.Class.Attributes, (yyPtrtTree)ADR((*yyNew)->U_1.V_5.Class.Attributes));
  5932.       yyCopyTree(yyt->U_1.V_5.Class.Extensions, (yyPtrtTree)ADR((*yyNew)->U_1.V_5.Class.Extensions));
  5933.       yyCopyTree(yyt->U_1.V_5.Class.BaseClass, (yyPtrtTree)ADR((*yyNew)->U_1.V_5.Class.BaseClass));
  5934.       yyCopyTree(yyt->U_1.V_5.Class.Formals, (yyPtrtTree)ADR((*yyNew)->U_1.V_5.Class.Formals));
  5935.       yyCopyTree(yyt->U_1.V_5.Class.TypeDesc, (yyPtrtTree)ADR((*yyNew)->U_1.V_5.Class.TypeDesc));
  5936.       yyt = yyt->U_1.V_5.Class.Next;
  5937.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_5.Class.Next);
  5938.       break;
  5939.     case Tree_Attributes:;
  5940.       (*yyNew)->U_1.V_6.Attributes = yyt->U_1.V_6.Attributes;
  5941.       return;
  5942.       break;
  5943.     case Tree_NoAttribute:;
  5944.       (*yyNew)->U_1.V_7.NoAttribute = yyt->U_1.V_7.NoAttribute;
  5945.       return;
  5946.       break;
  5947.     case Tree_AttrOrAction:;
  5948.       (*yyNew)->U_1.V_8.AttrOrAction = yyt->U_1.V_8.AttrOrAction;
  5949.       yyt = yyt->U_1.V_8.AttrOrAction.Next;
  5950.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_8.AttrOrAction.Next);
  5951.       break;
  5952.     case Tree_Child:;
  5953.       (*yyNew)->U_1.V_9.Child = yyt->U_1.V_9.Child;
  5954.       yyt = yyt->U_1.V_9.Child.Next;
  5955.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_9.Child.Next);
  5956.       break;
  5957.     case Tree_Attribute:;
  5958.       (*yyNew)->U_1.V_10.Attribute = yyt->U_1.V_10.Attribute;
  5959.       yyt = yyt->U_1.V_10.Attribute.Next;
  5960.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_10.Attribute.Next);
  5961.       break;
  5962.     case Tree_ActionPart:;
  5963.       (*yyNew)->U_1.V_11.ActionPart = yyt->U_1.V_11.ActionPart;
  5964.       yyt = yyt->U_1.V_11.ActionPart.Next;
  5965.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_11.ActionPart.Next);
  5966.       break;
  5967.     case Tree_Codes:;
  5968.       (*yyNew)->U_1.V_12.Codes = yyt->U_1.V_12.Codes;
  5969.       return;
  5970.       break;
  5971.     case Tree_Designators:;
  5972.       (*yyNew)->U_1.V_13.Designators = yyt->U_1.V_13.Designators;
  5973.       return;
  5974.       break;
  5975.     case Tree_NoDesignator:;
  5976.       (*yyNew)->U_1.V_14.NoDesignator = yyt->U_1.V_14.NoDesignator;
  5977.       return;
  5978.       break;
  5979.     case Tree_Designator:;
  5980.       (*yyNew)->U_1.V_15.Designator = yyt->U_1.V_15.Designator;
  5981.       yyt = yyt->U_1.V_15.Designator.Next;
  5982.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_15.Designator.Next);
  5983.       break;
  5984.     case Tree_Ident:;
  5985.       (*yyNew)->U_1.V_16.Ident = yyt->U_1.V_16.Ident;
  5986.       yyt = yyt->U_1.V_16.Ident.Next;
  5987.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_16.Ident.Next);
  5988.       break;
  5989.     case Tree_Remote:;
  5990.       (*yyNew)->U_1.V_17.Remote = yyt->U_1.V_17.Remote;
  5991.       yyCopyTree(yyt->U_1.V_17.Remote.Designators, (yyPtrtTree)ADR((*yyNew)->U_1.V_17.Remote.Designators));
  5992.       yyt = yyt->U_1.V_17.Remote.Next;
  5993.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_17.Remote.Next);
  5994.       break;
  5995.     case Tree_Any:;
  5996.       (*yyNew)->U_1.V_18.Any = yyt->U_1.V_18.Any;
  5997.       yyt = yyt->U_1.V_18.Any.Next;
  5998.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_18.Any.Next);
  5999.       break;
  6000.     case Tree_Anys:;
  6001.       (*yyNew)->U_1.V_19.Anys = yyt->U_1.V_19.Anys;
  6002.       yyCopyTree(yyt->U_1.V_19.Anys.Layouts, (yyPtrtTree)ADR((*yyNew)->U_1.V_19.Anys.Layouts));
  6003.       yyt = yyt->U_1.V_19.Anys.Next;
  6004.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_19.Anys.Next);
  6005.       break;
  6006.     case Tree_Layouts:;
  6007.       (*yyNew)->U_1.V_20.Layouts = yyt->U_1.V_20.Layouts;
  6008.       return;
  6009.       break;
  6010.     case Tree_NoLayout:;
  6011.       (*yyNew)->U_1.V_21.NoLayout = yyt->U_1.V_21.NoLayout;
  6012.       return;
  6013.       break;
  6014.     case Tree_LayoutAny:;
  6015.       (*yyNew)->U_1.V_22.LayoutAny = yyt->U_1.V_22.LayoutAny;
  6016.       yyt = yyt->U_1.V_22.LayoutAny.Next;
  6017.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_22.LayoutAny.Next);
  6018.       break;
  6019.     case Tree_Names:;
  6020.       (*yyNew)->U_1.V_23.Names = yyt->U_1.V_23.Names;
  6021.       return;
  6022.       break;
  6023.     case Tree_NoName:;
  6024.       (*yyNew)->U_1.V_24.NoName = yyt->U_1.V_24.NoName;
  6025.       return;
  6026.       break;
  6027.     case Tree_Name:;
  6028.       (*yyNew)->U_1.V_25.Name = yyt->U_1.V_25.Name;
  6029.       yyt = yyt->U_1.V_25.Name.Next;
  6030.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_25.Name.Next);
  6031.       break;
  6032.     case Tree_Spec:;
  6033.       (*yyNew)->U_1.V_26.Spec = yyt->U_1.V_26.Spec;
  6034.       yyCopyTree(yyt->U_1.V_26.Spec.TreeNames, (yyPtrtTree)ADR((*yyNew)->U_1.V_26.Spec.TreeNames));
  6035.       yyCopyTree(yyt->U_1.V_26.Spec.Public, (yyPtrtTree)ADR((*yyNew)->U_1.V_26.Spec.Public));
  6036.       yyCopyTree(yyt->U_1.V_26.Spec.Extern, (yyPtrtTree)ADR((*yyNew)->U_1.V_26.Spec.Extern));
  6037.       yyCopyTree(yyt->U_1.V_26.Spec.Codes, (yyPtrtTree)ADR((*yyNew)->U_1.V_26.Spec.Codes));
  6038.       yyt = yyt->U_1.V_26.Spec.Routines;
  6039.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_26.Spec.Routines);
  6040.       break;
  6041.     case Tree_TreeNames:;
  6042.       (*yyNew)->U_1.V_27.TreeNames = yyt->U_1.V_27.TreeNames;
  6043.       return;
  6044.       break;
  6045.     case Tree_NoTreeName:;
  6046.       (*yyNew)->U_1.V_28.NoTreeName = yyt->U_1.V_28.NoTreeName;
  6047.       return;
  6048.       break;
  6049.     case Tree_TreeName:;
  6050.       (*yyNew)->U_1.V_29.TreeName = yyt->U_1.V_29.TreeName;
  6051.       yyCopyTree(yyt->U_1.V_29.TreeName.Classes, (yyPtrtTree)ADR((*yyNew)->U_1.V_29.TreeName.Classes));
  6052.       yyt = yyt->U_1.V_29.TreeName.Next;
  6053.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_29.TreeName.Next);
  6054.       break;
  6055.     case Tree_Routines:;
  6056.       (*yyNew)->U_1.V_30.Routines = yyt->U_1.V_30.Routines;
  6057.       return;
  6058.       break;
  6059.     case Tree_NoRoutine:;
  6060.       (*yyNew)->U_1.V_31.NoRoutine = yyt->U_1.V_31.NoRoutine;
  6061.       return;
  6062.       break;
  6063.     case Tree_Routine:;
  6064.       (*yyNew)->U_1.V_32.Routine = yyt->U_1.V_32.Routine;
  6065.       yyCopyTree(yyt->U_1.V_32.Routine.InParams, (yyPtrtTree)ADR((*yyNew)->U_1.V_32.Routine.InParams));
  6066.       yyCopyTree(yyt->U_1.V_32.Routine.OutParams, (yyPtrtTree)ADR((*yyNew)->U_1.V_32.Routine.OutParams));
  6067.       yyCopyTree(yyt->U_1.V_32.Routine.Extern, (yyPtrtTree)ADR((*yyNew)->U_1.V_32.Routine.Extern));
  6068.       yyCopyTree(yyt->U_1.V_32.Routine.Rules, (yyPtrtTree)ADR((*yyNew)->U_1.V_32.Routine.Rules));
  6069.       yyCopyTree(yyt->U_1.V_32.Routine.InForm, (yyPtrtTree)ADR((*yyNew)->U_1.V_32.Routine.InForm));
  6070.       yyCopyTree(yyt->U_1.V_32.Routine.OutForm, (yyPtrtTree)ADR((*yyNew)->U_1.V_32.Routine.OutForm));
  6071.       yyCopyTree(yyt->U_1.V_32.Routine.ParamDecls, (yyPtrtTree)ADR((*yyNew)->U_1.V_32.Routine.ParamDecls));
  6072.       yyCopyTree(yyt->U_1.V_32.Routine.Decisions, (yyPtrtTree)ADR((*yyNew)->U_1.V_32.Routine.Decisions));
  6073.       yyt = yyt->U_1.V_32.Routine.Next;
  6074.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_32.Routine.Next);
  6075.       break;
  6076.     case Tree_Procedure:;
  6077.       (*yyNew)->U_1.V_33.Procedure = yyt->U_1.V_33.Procedure;
  6078.       yyCopyTree(yyt->U_1.V_33.Procedure.InParams, (yyPtrtTree)ADR((*yyNew)->U_1.V_33.Procedure.InParams));
  6079.       yyCopyTree(yyt->U_1.V_33.Procedure.OutParams, (yyPtrtTree)ADR((*yyNew)->U_1.V_33.Procedure.OutParams));
  6080.       yyCopyTree(yyt->U_1.V_33.Procedure.Extern, (yyPtrtTree)ADR((*yyNew)->U_1.V_33.Procedure.Extern));
  6081.       yyCopyTree(yyt->U_1.V_33.Procedure.Rules, (yyPtrtTree)ADR((*yyNew)->U_1.V_33.Procedure.Rules));
  6082.       yyCopyTree(yyt->U_1.V_33.Procedure.InForm, (yyPtrtTree)ADR((*yyNew)->U_1.V_33.Procedure.InForm));
  6083.       yyCopyTree(yyt->U_1.V_33.Procedure.OutForm, (yyPtrtTree)ADR((*yyNew)->U_1.V_33.Procedure.OutForm));
  6084.       yyCopyTree(yyt->U_1.V_33.Procedure.ParamDecls, (yyPtrtTree)ADR((*yyNew)->U_1.V_33.Procedure.ParamDecls));
  6085.       yyCopyTree(yyt->U_1.V_33.Procedure.Decisions, (yyPtrtTree)ADR((*yyNew)->U_1.V_33.Procedure.Decisions));
  6086.       yyt = yyt->U_1.V_33.Procedure.Next;
  6087.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_33.Procedure.Next);
  6088.       break;
  6089.     case Tree_Function:;
  6090.       (*yyNew)->U_1.V_34.Function = yyt->U_1.V_34.Function;
  6091.       yyCopyTree(yyt->U_1.V_34.Function.InParams, (yyPtrtTree)ADR((*yyNew)->U_1.V_34.Function.InParams));
  6092.       yyCopyTree(yyt->U_1.V_34.Function.OutParams, (yyPtrtTree)ADR((*yyNew)->U_1.V_34.Function.OutParams));
  6093.       yyCopyTree(yyt->U_1.V_34.Function.Extern, (yyPtrtTree)ADR((*yyNew)->U_1.V_34.Function.Extern));
  6094.       yyCopyTree(yyt->U_1.V_34.Function.Rules, (yyPtrtTree)ADR((*yyNew)->U_1.V_34.Function.Rules));
  6095.       yyCopyTree(yyt->U_1.V_34.Function.InForm, (yyPtrtTree)ADR((*yyNew)->U_1.V_34.Function.InForm));
  6096.       yyCopyTree(yyt->U_1.V_34.Function.OutForm, (yyPtrtTree)ADR((*yyNew)->U_1.V_34.Function.OutForm));
  6097.       yyCopyTree(yyt->U_1.V_34.Function.ParamDecls, (yyPtrtTree)ADR((*yyNew)->U_1.V_34.Function.ParamDecls));
  6098.       yyCopyTree(yyt->U_1.V_34.Function.Decisions, (yyPtrtTree)ADR((*yyNew)->U_1.V_34.Function.Decisions));
  6099.       yyCopyTree(yyt->U_1.V_34.Function.ReturnParams, (yyPtrtTree)ADR((*yyNew)->U_1.V_34.Function.ReturnParams));
  6100.       yyCopyTree(yyt->U_1.V_34.Function.ReturnForm, (yyPtrtTree)ADR((*yyNew)->U_1.V_34.Function.ReturnForm));
  6101.       yyt = yyt->U_1.V_34.Function.Next;
  6102.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_34.Function.Next);
  6103.       break;
  6104.     case Tree_Predicate:;
  6105.       (*yyNew)->U_1.V_35.Predicate = yyt->U_1.V_35.Predicate;
  6106.       yyCopyTree(yyt->U_1.V_35.Predicate.InParams, (yyPtrtTree)ADR((*yyNew)->U_1.V_35.Predicate.InParams));
  6107.       yyCopyTree(yyt->U_1.V_35.Predicate.OutParams, (yyPtrtTree)ADR((*yyNew)->U_1.V_35.Predicate.OutParams));
  6108.       yyCopyTree(yyt->U_1.V_35.Predicate.Extern, (yyPtrtTree)ADR((*yyNew)->U_1.V_35.Predicate.Extern));
  6109.       yyCopyTree(yyt->U_1.V_35.Predicate.Rules, (yyPtrtTree)ADR((*yyNew)->U_1.V_35.Predicate.Rules));
  6110.       yyCopyTree(yyt->U_1.V_35.Predicate.InForm, (yyPtrtTree)ADR((*yyNew)->U_1.V_35.Predicate.InForm));
  6111.       yyCopyTree(yyt->U_1.V_35.Predicate.OutForm, (yyPtrtTree)ADR((*yyNew)->U_1.V_35.Predicate.OutForm));
  6112.       yyCopyTree(yyt->U_1.V_35.Predicate.ParamDecls, (yyPtrtTree)ADR((*yyNew)->U_1.V_35.Predicate.ParamDecls));
  6113.       yyCopyTree(yyt->U_1.V_35.Predicate.Decisions, (yyPtrtTree)ADR((*yyNew)->U_1.V_35.Predicate.Decisions));
  6114.       yyt = yyt->U_1.V_35.Predicate.Next;
  6115.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_35.Predicate.Next);
  6116.       break;
  6117.     case Tree_Parameters:;
  6118.       (*yyNew)->U_1.V_36.Parameters = yyt->U_1.V_36.Parameters;
  6119.       return;
  6120.       break;
  6121.     case Tree_NoParameter:;
  6122.       (*yyNew)->U_1.V_37.NoParameter = yyt->U_1.V_37.NoParameter;
  6123.       return;
  6124.       break;
  6125.     case Tree_Param:;
  6126.       (*yyNew)->U_1.V_38.Param = yyt->U_1.V_38.Param;
  6127.       yyCopyTree(yyt->U_1.V_38.Param.Type, (yyPtrtTree)ADR((*yyNew)->U_1.V_38.Param.Type));
  6128.       yyt = yyt->U_1.V_38.Param.Next;
  6129.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_38.Param.Next);
  6130.       break;
  6131.     case Tree_Type:;
  6132.       (*yyNew)->U_1.V_39.Type = yyt->U_1.V_39.Type;
  6133.       yyt = yyt->U_1.V_39.Type.Names;
  6134.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_39.Type.Names);
  6135.       break;
  6136.     case Tree_Rules:;
  6137.       (*yyNew)->U_1.V_40.Rules = yyt->U_1.V_40.Rules;
  6138.       return;
  6139.       break;
  6140.     case Tree_NoRule:;
  6141.       (*yyNew)->U_1.V_41.NoRule = yyt->U_1.V_41.NoRule;
  6142.       return;
  6143.       break;
  6144.     case Tree_Rule:;
  6145.       (*yyNew)->U_1.V_42.Rule = yyt->U_1.V_42.Rule;
  6146.       yyCopyTree(yyt->U_1.V_42.Rule.Patterns, (yyPtrtTree)ADR((*yyNew)->U_1.V_42.Rule.Patterns));
  6147.       yyCopyTree(yyt->U_1.V_42.Rule.Exprs, (yyPtrtTree)ADR((*yyNew)->U_1.V_42.Rule.Exprs));
  6148.       yyCopyTree(yyt->U_1.V_42.Rule.Expr, (yyPtrtTree)ADR((*yyNew)->U_1.V_42.Rule.Expr));
  6149.       yyCopyTree(yyt->U_1.V_42.Rule.Statements, (yyPtrtTree)ADR((*yyNew)->U_1.V_42.Rule.Statements));
  6150.       yyCopyTree(yyt->U_1.V_42.Rule.VarDecls, (yyPtrtTree)ADR((*yyNew)->U_1.V_42.Rule.VarDecls));
  6151.       yyCopyTree(yyt->U_1.V_42.Rule.Tests, (yyPtrtTree)ADR((*yyNew)->U_1.V_42.Rule.Tests));
  6152.       yyt = yyt->U_1.V_42.Rule.Next;
  6153.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_42.Rule.Next);
  6154.       break;
  6155.     case Tree_Patterns:;
  6156.       (*yyNew)->U_1.V_43.Patterns = yyt->U_1.V_43.Patterns;
  6157.       return;
  6158.       break;
  6159.     case Tree_NoPattern:;
  6160.       (*yyNew)->U_1.V_44.NoPattern = yyt->U_1.V_44.NoPattern;
  6161.       return;
  6162.       break;
  6163.     case Tree_OnePattern:;
  6164.       (*yyNew)->U_1.V_45.OnePattern = yyt->U_1.V_45.OnePattern;
  6165.       yyCopyTree(yyt->U_1.V_45.OnePattern.Pattern, (yyPtrtTree)ADR((*yyNew)->U_1.V_45.OnePattern.Pattern));
  6166.       yyt = yyt->U_1.V_45.OnePattern.Next;
  6167.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_45.OnePattern.Next);
  6168.       break;
  6169.     case Tree_PatternsList:;
  6170.       (*yyNew)->U_1.V_46.PatternsList = yyt->U_1.V_46.PatternsList;
  6171.       return;
  6172.       break;
  6173.     case Tree_NoPatternsList:;
  6174.       (*yyNew)->U_1.V_47.NoPatternsList = yyt->U_1.V_47.NoPatternsList;
  6175.       return;
  6176.       break;
  6177.     case Tree_OnePatternsList:;
  6178.       (*yyNew)->U_1.V_48.OnePatternsList = yyt->U_1.V_48.OnePatternsList;
  6179.       yyCopyTree(yyt->U_1.V_48.OnePatternsList.Patterns, (yyPtrtTree)ADR((*yyNew)->U_1.V_48.OnePatternsList.Patterns));
  6180.       yyt = yyt->U_1.V_48.OnePatternsList.Next;
  6181.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_48.OnePatternsList.Next);
  6182.       break;
  6183.     case Tree_Pattern:;
  6184.       (*yyNew)->U_1.V_49.Pattern = yyt->U_1.V_49.Pattern;
  6185.       yyCopyTree(yyt->U_1.V_49.Pattern.TypeDesc, (yyPtrtTree)ADR((*yyNew)->U_1.V_49.Pattern.TypeDesc));
  6186.       yyt = yyt->U_1.V_49.Pattern.Path;
  6187.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_49.Pattern.Path);
  6188.       break;
  6189.     case Tree_Decompose:;
  6190.       (*yyNew)->U_1.V_50.Decompose = yyt->U_1.V_50.Decompose;
  6191.       yyCopyTree(yyt->U_1.V_50.Decompose.TypeDesc, (yyPtrtTree)ADR((*yyNew)->U_1.V_50.Decompose.TypeDesc));
  6192.       yyCopyTree(yyt->U_1.V_50.Decompose.Path, (yyPtrtTree)ADR((*yyNew)->U_1.V_50.Decompose.Path));
  6193.       yyCopyTree(yyt->U_1.V_50.Decompose.Expr, (yyPtrtTree)ADR((*yyNew)->U_1.V_50.Decompose.Expr));
  6194.       yyt = yyt->U_1.V_50.Decompose.Patterns;
  6195.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_50.Decompose.Patterns);
  6196.       break;
  6197.     case Tree_VarDef:;
  6198.       (*yyNew)->U_1.V_51.VarDef = yyt->U_1.V_51.VarDef;
  6199.       yyCopyTree(yyt->U_1.V_51.VarDef.TypeDesc, (yyPtrtTree)ADR((*yyNew)->U_1.V_51.VarDef.TypeDesc));
  6200.       yyt = yyt->U_1.V_51.VarDef.Path;
  6201.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_51.VarDef.Path);
  6202.       break;
  6203.     case Tree_NilTest:;
  6204.       (*yyNew)->U_1.V_52.NilTest = yyt->U_1.V_52.NilTest;
  6205.       yyCopyTree(yyt->U_1.V_52.NilTest.TypeDesc, (yyPtrtTree)ADR((*yyNew)->U_1.V_52.NilTest.TypeDesc));
  6206.       yyt = yyt->U_1.V_52.NilTest.Path;
  6207.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_52.NilTest.Path);
  6208.       break;
  6209.     case Tree_DontCare1:;
  6210.       (*yyNew)->U_1.V_53.DontCare1 = yyt->U_1.V_53.DontCare1;
  6211.       yyCopyTree(yyt->U_1.V_53.DontCare1.TypeDesc, (yyPtrtTree)ADR((*yyNew)->U_1.V_53.DontCare1.TypeDesc));
  6212.       yyt = yyt->U_1.V_53.DontCare1.Path;
  6213.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_53.DontCare1.Path);
  6214.       break;
  6215.     case Tree_DontCare:;
  6216.       (*yyNew)->U_1.V_54.DontCare = yyt->U_1.V_54.DontCare;
  6217.       yyCopyTree(yyt->U_1.V_54.DontCare.TypeDesc, (yyPtrtTree)ADR((*yyNew)->U_1.V_54.DontCare.TypeDesc));
  6218.       yyCopyTree(yyt->U_1.V_54.DontCare.Path, (yyPtrtTree)ADR((*yyNew)->U_1.V_54.DontCare.Path));
  6219.       yyt = yyt->U_1.V_54.DontCare.Tempos;
  6220.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_54.DontCare.Tempos);
  6221.       break;
  6222.     case Tree_Value:;
  6223.       (*yyNew)->U_1.V_55.Value = yyt->U_1.V_55.Value;
  6224.       yyCopyTree(yyt->U_1.V_55.Value.TypeDesc, (yyPtrtTree)ADR((*yyNew)->U_1.V_55.Value.TypeDesc));
  6225.       yyCopyTree(yyt->U_1.V_55.Value.Path, (yyPtrtTree)ADR((*yyNew)->U_1.V_55.Value.Path));
  6226.       yyt = yyt->U_1.V_55.Value.Expr;
  6227.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_55.Value.Expr);
  6228.       break;
  6229.     case Tree_Exprs:;
  6230.       (*yyNew)->U_1.V_56.Exprs = yyt->U_1.V_56.Exprs;
  6231.       return;
  6232.       break;
  6233.     case Tree_NoExpr:;
  6234.       (*yyNew)->U_1.V_57.NoExpr = yyt->U_1.V_57.NoExpr;
  6235.       return;
  6236.       break;
  6237.     case Tree_OneExpr:;
  6238.       (*yyNew)->U_1.V_58.OneExpr = yyt->U_1.V_58.OneExpr;
  6239.       yyCopyTree(yyt->U_1.V_58.OneExpr.Expr, (yyPtrtTree)ADR((*yyNew)->U_1.V_58.OneExpr.Expr));
  6240.       yyt = yyt->U_1.V_58.OneExpr.Next;
  6241.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_58.OneExpr.Next);
  6242.       break;
  6243.     case Tree_NamedExpr:;
  6244.       (*yyNew)->U_1.V_59.NamedExpr = yyt->U_1.V_59.NamedExpr;
  6245.       yyCopyTree(yyt->U_1.V_59.NamedExpr.Expr, (yyPtrtTree)ADR((*yyNew)->U_1.V_59.NamedExpr.Expr));
  6246.       yyt = yyt->U_1.V_59.NamedExpr.Next;
  6247.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_59.NamedExpr.Next);
  6248.       break;
  6249.     case Tree_Expr:;
  6250.       (*yyNew)->U_1.V_60.Expr = yyt->U_1.V_60.Expr;
  6251.       return;
  6252.       break;
  6253.     case Tree_Compose:;
  6254.       (*yyNew)->U_1.V_61.Compose = yyt->U_1.V_61.Compose;
  6255.       yyCopyTree(yyt->U_1.V_61.Compose.Expr, (yyPtrtTree)ADR((*yyNew)->U_1.V_61.Compose.Expr));
  6256.       yyCopyTree(yyt->U_1.V_61.Compose.Exprs, (yyPtrtTree)ADR((*yyNew)->U_1.V_61.Compose.Exprs));
  6257.       yyt = yyt->U_1.V_61.Compose.TypeDesc;
  6258.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_61.Compose.TypeDesc);
  6259.       break;
  6260.     case Tree_VarUse:;
  6261.       (*yyNew)->U_1.V_62.VarUse = yyt->U_1.V_62.VarUse;
  6262.       return;
  6263.       break;
  6264.     case Tree_AttrDesc:;
  6265.       (*yyNew)->U_1.V_63.AttrDesc = yyt->U_1.V_63.AttrDesc;
  6266.       return;
  6267.       break;
  6268.     case Tree_Nil:;
  6269.       (*yyNew)->U_1.V_64.Nil = yyt->U_1.V_64.Nil;
  6270.       return;
  6271.       break;
  6272.     case Tree_Call:;
  6273.       (*yyNew)->U_1.V_65.Call = yyt->U_1.V_65.Call;
  6274.       yyCopyTree(yyt->U_1.V_65.Call.Expr, (yyPtrtTree)ADR((*yyNew)->U_1.V_65.Call.Expr));
  6275.       yyCopyTree(yyt->U_1.V_65.Call.Exprs, (yyPtrtTree)ADR((*yyNew)->U_1.V_65.Call.Exprs));
  6276.       yyt = yyt->U_1.V_65.Call.Patterns;
  6277.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_65.Call.Patterns);
  6278.       break;
  6279.     case Tree_Binary:;
  6280.       (*yyNew)->U_1.V_66.Binary = yyt->U_1.V_66.Binary;
  6281.       yyCopyTree(yyt->U_1.V_66.Binary.Lop, (yyPtrtTree)ADR((*yyNew)->U_1.V_66.Binary.Lop));
  6282.       yyt = yyt->U_1.V_66.Binary.Rop;
  6283.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_66.Binary.Rop);
  6284.       break;
  6285.     case Tree_PreOperator:;
  6286.       (*yyNew)->U_1.V_67.PreOperator = yyt->U_1.V_67.PreOperator;
  6287.       yyt = yyt->U_1.V_67.PreOperator.Expr;
  6288.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_67.PreOperator.Expr);
  6289.       break;
  6290.     case Tree_PostOperator:;
  6291.       (*yyNew)->U_1.V_68.PostOperator = yyt->U_1.V_68.PostOperator;
  6292.       yyt = yyt->U_1.V_68.PostOperator.Expr;
  6293.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_68.PostOperator.Expr);
  6294.       break;
  6295.     case Tree_Index:;
  6296.       (*yyNew)->U_1.V_69.Index = yyt->U_1.V_69.Index;
  6297.       yyCopyTree(yyt->U_1.V_69.Index.Expr, (yyPtrtTree)ADR((*yyNew)->U_1.V_69.Index.Expr));
  6298.       yyt = yyt->U_1.V_69.Index.Exprs;
  6299.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_69.Index.Exprs);
  6300.       break;
  6301.     case Tree_Parents:;
  6302.       (*yyNew)->U_1.V_70.Parents = yyt->U_1.V_70.Parents;
  6303.       yyt = yyt->U_1.V_70.Parents.Expr;
  6304.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_70.Parents.Expr);
  6305.       break;
  6306.     case Tree_TargetExpr:;
  6307.       (*yyNew)->U_1.V_71.TargetExpr = yyt->U_1.V_71.TargetExpr;
  6308.       yyt = yyt->U_1.V_71.TargetExpr.Expr;
  6309.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_71.TargetExpr.Expr);
  6310.       break;
  6311.     case Tree_StringExpr:;
  6312.       (*yyNew)->U_1.V_72.StringExpr = yyt->U_1.V_72.StringExpr;
  6313.       return;
  6314.       break;
  6315.     case Tree_Statements:;
  6316.       (*yyNew)->U_1.V_73.Statements = yyt->U_1.V_73.Statements;
  6317.       return;
  6318.       break;
  6319.     case Tree_NoStatement:;
  6320.       (*yyNew)->U_1.V_74.NoStatement = yyt->U_1.V_74.NoStatement;
  6321.       return;
  6322.       break;
  6323.     case Tree_Statement:;
  6324.       (*yyNew)->U_1.V_75.Statement = yyt->U_1.V_75.Statement;
  6325.       yyt = yyt->U_1.V_75.Statement.Next;
  6326.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_75.Statement.Next);
  6327.       break;
  6328.     case Tree_ProcCall:;
  6329.       (*yyNew)->U_1.V_76.ProcCall = yyt->U_1.V_76.ProcCall;
  6330.       yyCopyTree(yyt->U_1.V_76.ProcCall.Call, (yyPtrtTree)ADR((*yyNew)->U_1.V_76.ProcCall.Call));
  6331.       yyt = yyt->U_1.V_76.ProcCall.Next;
  6332.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_76.ProcCall.Next);
  6333.       break;
  6334.     case Tree_Condition:;
  6335.       (*yyNew)->U_1.V_77.Condition = yyt->U_1.V_77.Condition;
  6336.       yyCopyTree(yyt->U_1.V_77.Condition.Expr, (yyPtrtTree)ADR((*yyNew)->U_1.V_77.Condition.Expr));
  6337.       yyt = yyt->U_1.V_77.Condition.Next;
  6338.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_77.Condition.Next);
  6339.       break;
  6340.     case Tree_Assignment:;
  6341.       (*yyNew)->U_1.V_78.Assignment = yyt->U_1.V_78.Assignment;
  6342.       yyCopyTree(yyt->U_1.V_78.Assignment.Adr, (yyPtrtTree)ADR((*yyNew)->U_1.V_78.Assignment.Adr));
  6343.       yyCopyTree(yyt->U_1.V_78.Assignment.Expr, (yyPtrtTree)ADR((*yyNew)->U_1.V_78.Assignment.Expr));
  6344.       yyt = yyt->U_1.V_78.Assignment.Next;
  6345.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_78.Assignment.Next);
  6346.       break;
  6347.     case Tree_Reject:;
  6348.       (*yyNew)->U_1.V_79.Reject = yyt->U_1.V_79.Reject;
  6349.       yyt = yyt->U_1.V_79.Reject.Next;
  6350.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_79.Reject.Next);
  6351.       break;
  6352.     case Tree_Fail:;
  6353.       (*yyNew)->U_1.V_80.Fail = yyt->U_1.V_80.Fail;
  6354.       yyt = yyt->U_1.V_80.Fail.Next;
  6355.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_80.Fail.Next);
  6356.       break;
  6357.     case Tree_TargetStmt:;
  6358.       (*yyNew)->U_1.V_81.TargetStmt = yyt->U_1.V_81.TargetStmt;
  6359.       yyCopyTree(yyt->U_1.V_81.TargetStmt.Parameters, (yyPtrtTree)ADR((*yyNew)->U_1.V_81.TargetStmt.Parameters));
  6360.       yyCopyTree(yyt->U_1.V_81.TargetStmt.Stmt, (yyPtrtTree)ADR((*yyNew)->U_1.V_81.TargetStmt.Stmt));
  6361.       yyt = yyt->U_1.V_81.TargetStmt.Next;
  6362.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_81.TargetStmt.Next);
  6363.       break;
  6364.     case Tree_Nl:;
  6365.       (*yyNew)->U_1.V_82.Nl = yyt->U_1.V_82.Nl;
  6366.       yyt = yyt->U_1.V_82.Nl.Next;
  6367.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_82.Nl.Next);
  6368.       break;
  6369.     case Tree_WriteStr:;
  6370.       (*yyNew)->U_1.V_83.WriteStr = yyt->U_1.V_83.WriteStr;
  6371.       yyt = yyt->U_1.V_83.WriteStr.Next;
  6372.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_83.WriteStr.Next);
  6373.       break;
  6374.     case Tree_Formals:;
  6375.       (*yyNew)->U_1.V_84.Formals = yyt->U_1.V_84.Formals;
  6376.       return;
  6377.       break;
  6378.     case Tree_NoFormal:;
  6379.       (*yyNew)->U_1.V_85.NoFormal = yyt->U_1.V_85.NoFormal;
  6380.       return;
  6381.       break;
  6382.     case Tree_Formal:;
  6383.       (*yyNew)->U_1.V_86.Formal = yyt->U_1.V_86.Formal;
  6384.       yyCopyTree(yyt->U_1.V_86.Formal.TypeDesc, (yyPtrtTree)ADR((*yyNew)->U_1.V_86.Formal.TypeDesc));
  6385.       yyCopyTree(yyt->U_1.V_86.Formal.Path, (yyPtrtTree)ADR((*yyNew)->U_1.V_86.Formal.Path));
  6386.       yyt = yyt->U_1.V_86.Formal.Next;
  6387.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_86.Formal.Next);
  6388.       break;
  6389.     case Tree_DummyFormal:;
  6390.       (*yyNew)->U_1.V_87.DummyFormal = yyt->U_1.V_87.DummyFormal;
  6391.       yyt = yyt->U_1.V_87.DummyFormal.Next;
  6392.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_87.DummyFormal.Next);
  6393.       break;
  6394.     case Tree_TypeDesc:;
  6395.       (*yyNew)->U_1.V_88.TypeDesc = yyt->U_1.V_88.TypeDesc;
  6396.       return;
  6397.       break;
  6398.     case Tree_NodeTypes:;
  6399.       (*yyNew)->U_1.V_89.NodeTypes = yyt->U_1.V_89.NodeTypes;
  6400.       yyt = yyt->U_1.V_89.NodeTypes.TreeName;
  6401.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_89.NodeTypes.TreeName);
  6402.       break;
  6403.     case Tree_UserType:;
  6404.       (*yyNew)->U_1.V_90.UserType = yyt->U_1.V_90.UserType;
  6405.       return;
  6406.       break;
  6407.     case Tree_Path:;
  6408.       (*yyNew)->U_1.V_91.Path = yyt->U_1.V_91.Path;
  6409.       return;
  6410.       break;
  6411.     case Tree_Var:;
  6412.       (*yyNew)->U_1.V_92.Var = yyt->U_1.V_92.Var;
  6413.       return;
  6414.       break;
  6415.     case Tree_ConsType:;
  6416.       (*yyNew)->U_1.V_93.ConsType = yyt->U_1.V_93.ConsType;
  6417.       yyt = yyt->U_1.V_93.ConsType.Next;
  6418.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_93.ConsType.Next);
  6419.       break;
  6420.     case Tree_Field:;
  6421.       (*yyNew)->U_1.V_94.Field = yyt->U_1.V_94.Field;
  6422.       yyt = yyt->U_1.V_94.Field.Next;
  6423.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_94.Field.Next);
  6424.       break;
  6425.     case Tree_Tests:;
  6426.       (*yyNew)->U_1.V_95.Tests = yyt->U_1.V_95.Tests;
  6427.       return;
  6428.       break;
  6429.     case Tree_NoTest:;
  6430.       (*yyNew)->U_1.V_96.NoTest = yyt->U_1.V_96.NoTest;
  6431.       return;
  6432.       break;
  6433.     case Tree_OneTest:;
  6434.       (*yyNew)->U_1.V_97.OneTest = yyt->U_1.V_97.OneTest;
  6435.       yyCopyTree(yyt->U_1.V_97.OneTest.Next, (yyPtrtTree)ADR((*yyNew)->U_1.V_97.OneTest.Next));
  6436.       yyt = yyt->U_1.V_97.OneTest.Path;
  6437.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_97.OneTest.Path);
  6438.       break;
  6439.     case Tree_TestKind:;
  6440.       (*yyNew)->U_1.V_98.TestKind = yyt->U_1.V_98.TestKind;
  6441.       yyCopyTree(yyt->U_1.V_98.TestKind.Next, (yyPtrtTree)ADR((*yyNew)->U_1.V_98.TestKind.Next));
  6442.       yyCopyTree(yyt->U_1.V_98.TestKind.Path, (yyPtrtTree)ADR((*yyNew)->U_1.V_98.TestKind.Path));
  6443.       yyt = yyt->U_1.V_98.TestKind.TypeDesc;
  6444.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_98.TestKind.TypeDesc);
  6445.       break;
  6446.     case Tree_TestIsType:;
  6447.       (*yyNew)->U_1.V_99.TestIsType = yyt->U_1.V_99.TestIsType;
  6448.       yyCopyTree(yyt->U_1.V_99.TestIsType.Next, (yyPtrtTree)ADR((*yyNew)->U_1.V_99.TestIsType.Next));
  6449.       yyCopyTree(yyt->U_1.V_99.TestIsType.Path, (yyPtrtTree)ADR((*yyNew)->U_1.V_99.TestIsType.Path));
  6450.       yyt = yyt->U_1.V_99.TestIsType.TypeDesc;
  6451.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_99.TestIsType.TypeDesc);
  6452.       break;
  6453.     case Tree_TestNil:;
  6454.       (*yyNew)->U_1.V_100.TestNil = yyt->U_1.V_100.TestNil;
  6455.       yyCopyTree(yyt->U_1.V_100.TestNil.Next, (yyPtrtTree)ADR((*yyNew)->U_1.V_100.TestNil.Next));
  6456.       yyt = yyt->U_1.V_100.TestNil.Path;
  6457.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_100.TestNil.Path);
  6458.       break;
  6459.     case Tree_TestNonlin:;
  6460.       (*yyNew)->U_1.V_101.TestNonlin = yyt->U_1.V_101.TestNonlin;
  6461.       yyCopyTree(yyt->U_1.V_101.TestNonlin.Next, (yyPtrtTree)ADR((*yyNew)->U_1.V_101.TestNonlin.Next));
  6462.       yyCopyTree(yyt->U_1.V_101.TestNonlin.Path, (yyPtrtTree)ADR((*yyNew)->U_1.V_101.TestNonlin.Path));
  6463.       yyCopyTree(yyt->U_1.V_101.TestNonlin.Path2, (yyPtrtTree)ADR((*yyNew)->U_1.V_101.TestNonlin.Path2));
  6464.       yyt = yyt->U_1.V_101.TestNonlin.TypeDesc;
  6465.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_101.TestNonlin.TypeDesc);
  6466.       break;
  6467.     case Tree_TestValue:;
  6468.       (*yyNew)->U_1.V_102.TestValue = yyt->U_1.V_102.TestValue;
  6469.       yyCopyTree(yyt->U_1.V_102.TestValue.Next, (yyPtrtTree)ADR((*yyNew)->U_1.V_102.TestValue.Next));
  6470.       yyCopyTree(yyt->U_1.V_102.TestValue.Path, (yyPtrtTree)ADR((*yyNew)->U_1.V_102.TestValue.Path));
  6471.       yyCopyTree(yyt->U_1.V_102.TestValue.Expr, (yyPtrtTree)ADR((*yyNew)->U_1.V_102.TestValue.Expr));
  6472.       yyt = yyt->U_1.V_102.TestValue.TypeDesc;
  6473.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_102.TestValue.TypeDesc);
  6474.       break;
  6475.     case Tree_Decisions:;
  6476.       (*yyNew)->U_1.V_103.Decisions = yyt->U_1.V_103.Decisions;
  6477.       return;
  6478.       break;
  6479.     case Tree_NoDecision:;
  6480.       (*yyNew)->U_1.V_104.NoDecision = yyt->U_1.V_104.NoDecision;
  6481.       return;
  6482.       break;
  6483.     case Tree_Decision:;
  6484.       (*yyNew)->U_1.V_105.Decision = yyt->U_1.V_105.Decision;
  6485.       yyCopyTree(yyt->U_1.V_105.Decision.Then, (yyPtrtTree)ADR((*yyNew)->U_1.V_105.Decision.Then));
  6486.       yyCopyTree(yyt->U_1.V_105.Decision.Else, (yyPtrtTree)ADR((*yyNew)->U_1.V_105.Decision.Else));
  6487.       yyt = yyt->U_1.V_105.Decision.OneTest;
  6488.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_105.Decision.OneTest);
  6489.       break;
  6490.     case Tree_Decided:;
  6491.       (*yyNew)->U_1.V_106.Decided = yyt->U_1.V_106.Decided;
  6492.       yyCopyTree(yyt->U_1.V_106.Decided.Else, (yyPtrtTree)ADR((*yyNew)->U_1.V_106.Decided.Else));
  6493.       yyt = yyt->U_1.V_106.Decided.Rule;
  6494.       yyNew = (yyPtrtTree)ADR((*yyNew)->U_1.V_106.Decided.Rule);
  6495.       break;
  6496.     default :
  6497.       break;
  6498.     }
  6499.   } EXIT_5:;
  6500. }
  6501.  
  6502. Tree_tTree Tree_CopyTree
  6503. # ifdef __STDC__
  6504. (Tree_tTree yyt)
  6505. # else
  6506. (yyt)
  6507. Tree_tTree yyt;
  6508. # endif
  6509. {
  6510.   Tree_tTree yyNew;
  6511.  
  6512.   yyMark(yyt);
  6513.   yyOldToNewCount = 0;
  6514.   yyCopyTree(yyt, (yyPtrtTree)ADR(yyNew));
  6515.   return yyNew;
  6516. }
  6517.  
  6518. static BOOLEAN yyyIsEqual
  6519. # ifdef __STDC__
  6520. (CHAR yya[], LONGCARD O_3)
  6521. # else
  6522. (yya, O_3)
  6523. CHAR yya[];
  6524. LONGCARD O_3;
  6525. # endif
  6526. {
  6527.   INTEGER yyi;
  6528.   OPEN_ARRAY_LOCALS
  6529.  
  6530.   ALLOC_OPEN_ARRAYS(O_3 * sizeof(CHAR), 1)
  6531.   COPY_OPEN_ARRAY(yya, O_3, CHAR)
  6532.   if (yyLength >= 0 && yyString.A[yyLength] == ' ') {
  6533.     if (yyLength - 1 != (INTEGER)(O_3 - 1)) {
  6534.       FREE_OPEN_ARRAYS
  6535.       return FALSE;
  6536.     }
  6537.     {
  6538.       LONGINT B_9 = 0, B_10 = yyLength - 1;
  6539.  
  6540.       if (B_9 <= B_10)
  6541.         for (yyi = B_9;; yyi += 1) {
  6542.           if (yyString.A[yyi] != yya[yyi]) {
  6543.             FREE_OPEN_ARRAYS
  6544.             return FALSE;
  6545.           }
  6546.           if (yyi >= B_10) break;
  6547.         }
  6548.     }
  6549.   } else {
  6550.     if (yyLength > (INTEGER)(O_3 - 1)) {
  6551.       FREE_OPEN_ARRAYS
  6552.       return FALSE;
  6553.     }
  6554.     {
  6555.       LONGINT B_11 = 0, B_12 = yyLength;
  6556.  
  6557.       if (B_11 <= B_12)
  6558.         for (yyi = B_11;; yyi += 1) {
  6559.           if (yyString.A[yyi] != yya[yyi]) {
  6560.             FREE_OPEN_ARRAYS
  6561.             return FALSE;
  6562.           }
  6563.           if (yyi >= B_12) break;
  6564.         }
  6565.     }
  6566.   }
  6567.   FREE_OPEN_ARRAYS
  6568.   return TRUE;
  6569. }
  6570.  
  6571. void Tree_QueryTree
  6572. # ifdef __STDC__
  6573. (Tree_tTree yyt)
  6574. # else
  6575. (yyt)
  6576. Tree_tTree yyt;
  6577. # endif
  6578. {
  6579.   yyState = yyyWrite;
  6580.   for (;;) {
  6581.     switch (yyState) {
  6582.     case yyyQuit:;
  6583.       return;
  6584.       break;
  6585.     case yyyWrite:;
  6586.       Tree_WriteTreeNode((System_tFile)IO_StdOutput, yyt);
  6587.       yyState = yyyRead;
  6588.       break;
  6589.     case yyyRead:;
  6590.       IO_WriteS((System_tFile)IO_StdOutput, (STRING)"? ", 2L);
  6591.       yyLength = -1;
  6592.       yyCh = IO_ReadC((System_tFile)IO_StdInput);
  6593.       while (yyCh != '\n') {
  6594.         INC(yyLength);
  6595.         yyString.A[yyLength] = yyCh;
  6596.         yyCh = IO_ReadC((System_tFile)IO_StdInput);
  6597.       }
  6598.       if (yyyIsEqual((STRING)"parent", 6L)) {
  6599.         yyState = yyyWrite;
  6600.         return;
  6601.       } else if (yyyIsEqual((STRING)"quit", 4L)) {
  6602.         yyState = yyyQuit;
  6603.         return;
  6604.       } else if (yyt != Tree_NoTree) {
  6605.         switch (yyt->U_1.V_1.Kind) {
  6606.         case Tree_Class:;
  6607.           if (FALSE) {
  6608.           } else if (yyyIsEqual((STRING)"Attributes", 10L)) {
  6609.             Tree_QueryTree(yyt->U_1.V_5.Class.Attributes);
  6610.           } else if (yyyIsEqual((STRING)"Extensions", 10L)) {
  6611.             Tree_QueryTree(yyt->U_1.V_5.Class.Extensions);
  6612.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  6613.             Tree_QueryTree(yyt->U_1.V_5.Class.Next);
  6614.           } else if (yyyIsEqual((STRING)"BaseClass", 9L)) {
  6615.             Tree_QueryTree(yyt->U_1.V_5.Class.BaseClass);
  6616.           } else if (yyyIsEqual((STRING)"Formals", 7L)) {
  6617.             Tree_QueryTree(yyt->U_1.V_5.Class.Formals);
  6618.           } else if (yyyIsEqual((STRING)"TypeDesc", 8L)) {
  6619.             Tree_QueryTree(yyt->U_1.V_5.Class.TypeDesc);
  6620.           }
  6621.           break;
  6622.         case Tree_AttrOrAction:;
  6623.           if (FALSE) {
  6624.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  6625.             Tree_QueryTree(yyt->U_1.V_8.AttrOrAction.Next);
  6626.           }
  6627.           break;
  6628.         case Tree_Child:;
  6629.           if (FALSE) {
  6630.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  6631.             Tree_QueryTree(yyt->U_1.V_9.Child.Next);
  6632.           }
  6633.           break;
  6634.         case Tree_Attribute:;
  6635.           if (FALSE) {
  6636.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  6637.             Tree_QueryTree(yyt->U_1.V_10.Attribute.Next);
  6638.           }
  6639.           break;
  6640.         case Tree_ActionPart:;
  6641.           if (FALSE) {
  6642.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  6643.             Tree_QueryTree(yyt->U_1.V_11.ActionPart.Next);
  6644.           }
  6645.           break;
  6646.         case Tree_Designator:;
  6647.           if (FALSE) {
  6648.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  6649.             Tree_QueryTree(yyt->U_1.V_15.Designator.Next);
  6650.           }
  6651.           break;
  6652.         case Tree_Ident:;
  6653.           if (FALSE) {
  6654.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  6655.             Tree_QueryTree(yyt->U_1.V_16.Ident.Next);
  6656.           }
  6657.           break;
  6658.         case Tree_Remote:;
  6659.           if (FALSE) {
  6660.           } else if (yyyIsEqual((STRING)"Designators", 11L)) {
  6661.             Tree_QueryTree(yyt->U_1.V_17.Remote.Designators);
  6662.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  6663.             Tree_QueryTree(yyt->U_1.V_17.Remote.Next);
  6664.           }
  6665.           break;
  6666.         case Tree_Any:;
  6667.           if (FALSE) {
  6668.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  6669.             Tree_QueryTree(yyt->U_1.V_18.Any.Next);
  6670.           }
  6671.           break;
  6672.         case Tree_Anys:;
  6673.           if (FALSE) {
  6674.           } else if (yyyIsEqual((STRING)"Layouts", 7L)) {
  6675.             Tree_QueryTree(yyt->U_1.V_19.Anys.Layouts);
  6676.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  6677.             Tree_QueryTree(yyt->U_1.V_19.Anys.Next);
  6678.           }
  6679.           break;
  6680.         case Tree_LayoutAny:;
  6681.           if (FALSE) {
  6682.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  6683.             Tree_QueryTree(yyt->U_1.V_22.LayoutAny.Next);
  6684.           }
  6685.           break;
  6686.         case Tree_Name:;
  6687.           if (FALSE) {
  6688.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  6689.             Tree_QueryTree(yyt->U_1.V_25.Name.Next);
  6690.           }
  6691.           break;
  6692.         case Tree_Spec:;
  6693.           if (FALSE) {
  6694.           } else if (yyyIsEqual((STRING)"TreeNames", 9L)) {
  6695.             Tree_QueryTree(yyt->U_1.V_26.Spec.TreeNames);
  6696.           } else if (yyyIsEqual((STRING)"Public", 6L)) {
  6697.             Tree_QueryTree(yyt->U_1.V_26.Spec.Public);
  6698.           } else if (yyyIsEqual((STRING)"Extern", 6L)) {
  6699.             Tree_QueryTree(yyt->U_1.V_26.Spec.Extern);
  6700.           } else if (yyyIsEqual((STRING)"Codes", 5L)) {
  6701.             Tree_QueryTree(yyt->U_1.V_26.Spec.Codes);
  6702.           } else if (yyyIsEqual((STRING)"Routines", 8L)) {
  6703.             Tree_QueryTree(yyt->U_1.V_26.Spec.Routines);
  6704.           }
  6705.           break;
  6706.         case Tree_TreeName:;
  6707.           if (FALSE) {
  6708.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  6709.             Tree_QueryTree(yyt->U_1.V_29.TreeName.Next);
  6710.           } else if (yyyIsEqual((STRING)"Classes", 7L)) {
  6711.             Tree_QueryTree(yyt->U_1.V_29.TreeName.Classes);
  6712.           }
  6713.           break;
  6714.         case Tree_Routine:;
  6715.           if (FALSE) {
  6716.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  6717.             Tree_QueryTree(yyt->U_1.V_32.Routine.Next);
  6718.           } else if (yyyIsEqual((STRING)"InParams", 8L)) {
  6719.             Tree_QueryTree(yyt->U_1.V_32.Routine.InParams);
  6720.           } else if (yyyIsEqual((STRING)"OutParams", 9L)) {
  6721.             Tree_QueryTree(yyt->U_1.V_32.Routine.OutParams);
  6722.           } else if (yyyIsEqual((STRING)"Extern", 6L)) {
  6723.             Tree_QueryTree(yyt->U_1.V_32.Routine.Extern);
  6724.           } else if (yyyIsEqual((STRING)"Rules", 5L)) {
  6725.             Tree_QueryTree(yyt->U_1.V_32.Routine.Rules);
  6726.           } else if (yyyIsEqual((STRING)"InForm", 6L)) {
  6727.             Tree_QueryTree(yyt->U_1.V_32.Routine.InForm);
  6728.           } else if (yyyIsEqual((STRING)"OutForm", 7L)) {
  6729.             Tree_QueryTree(yyt->U_1.V_32.Routine.OutForm);
  6730.           } else if (yyyIsEqual((STRING)"ParamDecls", 10L)) {
  6731.             Tree_QueryTree(yyt->U_1.V_32.Routine.ParamDecls);
  6732.           } else if (yyyIsEqual((STRING)"Decisions", 9L)) {
  6733.             Tree_QueryTree(yyt->U_1.V_32.Routine.Decisions);
  6734.           }
  6735.           break;
  6736.         case Tree_Procedure:;
  6737.           if (FALSE) {
  6738.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  6739.             Tree_QueryTree(yyt->U_1.V_33.Procedure.Next);
  6740.           } else if (yyyIsEqual((STRING)"InParams", 8L)) {
  6741.             Tree_QueryTree(yyt->U_1.V_33.Procedure.InParams);
  6742.           } else if (yyyIsEqual((STRING)"OutParams", 9L)) {
  6743.             Tree_QueryTree(yyt->U_1.V_33.Procedure.OutParams);
  6744.           } else if (yyyIsEqual((STRING)"Extern", 6L)) {
  6745.             Tree_QueryTree(yyt->U_1.V_33.Procedure.Extern);
  6746.           } else if (yyyIsEqual((STRING)"Rules", 5L)) {
  6747.             Tree_QueryTree(yyt->U_1.V_33.Procedure.Rules);
  6748.           } else if (yyyIsEqual((STRING)"InForm", 6L)) {
  6749.             Tree_QueryTree(yyt->U_1.V_33.Procedure.InForm);
  6750.           } else if (yyyIsEqual((STRING)"OutForm", 7L)) {
  6751.             Tree_QueryTree(yyt->U_1.V_33.Procedure.OutForm);
  6752.           } else if (yyyIsEqual((STRING)"ParamDecls", 10L)) {
  6753.             Tree_QueryTree(yyt->U_1.V_33.Procedure.ParamDecls);
  6754.           } else if (yyyIsEqual((STRING)"Decisions", 9L)) {
  6755.             Tree_QueryTree(yyt->U_1.V_33.Procedure.Decisions);
  6756.           }
  6757.           break;
  6758.         case Tree_Function:;
  6759.           if (FALSE) {
  6760.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  6761.             Tree_QueryTree(yyt->U_1.V_34.Function.Next);
  6762.           } else if (yyyIsEqual((STRING)"InParams", 8L)) {
  6763.             Tree_QueryTree(yyt->U_1.V_34.Function.InParams);
  6764.           } else if (yyyIsEqual((STRING)"OutParams", 9L)) {
  6765.             Tree_QueryTree(yyt->U_1.V_34.Function.OutParams);
  6766.           } else if (yyyIsEqual((STRING)"Extern", 6L)) {
  6767.             Tree_QueryTree(yyt->U_1.V_34.Function.Extern);
  6768.           } else if (yyyIsEqual((STRING)"Rules", 5L)) {
  6769.             Tree_QueryTree(yyt->U_1.V_34.Function.Rules);
  6770.           } else if (yyyIsEqual((STRING)"InForm", 6L)) {
  6771.             Tree_QueryTree(yyt->U_1.V_34.Function.InForm);
  6772.           } else if (yyyIsEqual((STRING)"OutForm", 7L)) {
  6773.             Tree_QueryTree(yyt->U_1.V_34.Function.OutForm);
  6774.           } else if (yyyIsEqual((STRING)"ParamDecls", 10L)) {
  6775.             Tree_QueryTree(yyt->U_1.V_34.Function.ParamDecls);
  6776.           } else if (yyyIsEqual((STRING)"Decisions", 9L)) {
  6777.             Tree_QueryTree(yyt->U_1.V_34.Function.Decisions);
  6778.           } else if (yyyIsEqual((STRING)"ReturnParams", 12L)) {
  6779.             Tree_QueryTree(yyt->U_1.V_34.Function.ReturnParams);
  6780.           } else if (yyyIsEqual((STRING)"ReturnForm", 10L)) {
  6781.             Tree_QueryTree(yyt->U_1.V_34.Function.ReturnForm);
  6782.           }
  6783.           break;
  6784.         case Tree_Predicate:;
  6785.           if (FALSE) {
  6786.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  6787.             Tree_QueryTree(yyt->U_1.V_35.Predicate.Next);
  6788.           } else if (yyyIsEqual((STRING)"InParams", 8L)) {
  6789.             Tree_QueryTree(yyt->U_1.V_35.Predicate.InParams);
  6790.           } else if (yyyIsEqual((STRING)"OutParams", 9L)) {
  6791.             Tree_QueryTree(yyt->U_1.V_35.Predicate.OutParams);
  6792.           } else if (yyyIsEqual((STRING)"Extern", 6L)) {
  6793.             Tree_QueryTree(yyt->U_1.V_35.Predicate.Extern);
  6794.           } else if (yyyIsEqual((STRING)"Rules", 5L)) {
  6795.             Tree_QueryTree(yyt->U_1.V_35.Predicate.Rules);
  6796.           } else if (yyyIsEqual((STRING)"InForm", 6L)) {
  6797.             Tree_QueryTree(yyt->U_1.V_35.Predicate.InForm);
  6798.           } else if (yyyIsEqual((STRING)"OutForm", 7L)) {
  6799.             Tree_QueryTree(yyt->U_1.V_35.Predicate.OutForm);
  6800.           } else if (yyyIsEqual((STRING)"ParamDecls", 10L)) {
  6801.             Tree_QueryTree(yyt->U_1.V_35.Predicate.ParamDecls);
  6802.           } else if (yyyIsEqual((STRING)"Decisions", 9L)) {
  6803.             Tree_QueryTree(yyt->U_1.V_35.Predicate.Decisions);
  6804.           }
  6805.           break;
  6806.         case Tree_Param:;
  6807.           if (FALSE) {
  6808.           } else if (yyyIsEqual((STRING)"Type", 4L)) {
  6809.             Tree_QueryTree(yyt->U_1.V_38.Param.Type);
  6810.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  6811.             Tree_QueryTree(yyt->U_1.V_38.Param.Next);
  6812.           }
  6813.           break;
  6814.         case Tree_Type:;
  6815.           if (FALSE) {
  6816.           } else if (yyyIsEqual((STRING)"Names", 5L)) {
  6817.             Tree_QueryTree(yyt->U_1.V_39.Type.Names);
  6818.           }
  6819.           break;
  6820.         case Tree_Rule:;
  6821.           if (FALSE) {
  6822.           } else if (yyyIsEqual((STRING)"Patterns", 8L)) {
  6823.             Tree_QueryTree(yyt->U_1.V_42.Rule.Patterns);
  6824.           } else if (yyyIsEqual((STRING)"Exprs", 5L)) {
  6825.             Tree_QueryTree(yyt->U_1.V_42.Rule.Exprs);
  6826.           } else if (yyyIsEqual((STRING)"Expr", 4L)) {
  6827.             Tree_QueryTree(yyt->U_1.V_42.Rule.Expr);
  6828.           } else if (yyyIsEqual((STRING)"Statements", 10L)) {
  6829.             Tree_QueryTree(yyt->U_1.V_42.Rule.Statements);
  6830.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  6831.             Tree_QueryTree(yyt->U_1.V_42.Rule.Next);
  6832.           } else if (yyyIsEqual((STRING)"VarDecls", 8L)) {
  6833.             Tree_QueryTree(yyt->U_1.V_42.Rule.VarDecls);
  6834.           } else if (yyyIsEqual((STRING)"Tests", 5L)) {
  6835.             Tree_QueryTree(yyt->U_1.V_42.Rule.Tests);
  6836.           }
  6837.           break;
  6838.         case Tree_OnePattern:;
  6839.           if (FALSE) {
  6840.           } else if (yyyIsEqual((STRING)"Pattern", 7L)) {
  6841.             Tree_QueryTree(yyt->U_1.V_45.OnePattern.Pattern);
  6842.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  6843.             Tree_QueryTree(yyt->U_1.V_45.OnePattern.Next);
  6844.           }
  6845.           break;
  6846.         case Tree_OnePatternsList:;
  6847.           if (FALSE) {
  6848.           } else if (yyyIsEqual((STRING)"Patterns", 8L)) {
  6849.             Tree_QueryTree(yyt->U_1.V_48.OnePatternsList.Patterns);
  6850.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  6851.             Tree_QueryTree(yyt->U_1.V_48.OnePatternsList.Next);
  6852.           }
  6853.           break;
  6854.         case Tree_Pattern:;
  6855.           if (FALSE) {
  6856.           } else if (yyyIsEqual((STRING)"TypeDesc", 8L)) {
  6857.             Tree_QueryTree(yyt->U_1.V_49.Pattern.TypeDesc);
  6858.           } else if (yyyIsEqual((STRING)"Path", 4L)) {
  6859.             Tree_QueryTree(yyt->U_1.V_49.Pattern.Path);
  6860.           }
  6861.           break;
  6862.         case Tree_Decompose:;
  6863.           if (FALSE) {
  6864.           } else if (yyyIsEqual((STRING)"TypeDesc", 8L)) {
  6865.             Tree_QueryTree(yyt->U_1.V_50.Decompose.TypeDesc);
  6866.           } else if (yyyIsEqual((STRING)"Path", 4L)) {
  6867.             Tree_QueryTree(yyt->U_1.V_50.Decompose.Path);
  6868.           } else if (yyyIsEqual((STRING)"Expr", 4L)) {
  6869.             Tree_QueryTree(yyt->U_1.V_50.Decompose.Expr);
  6870.           } else if (yyyIsEqual((STRING)"Patterns", 8L)) {
  6871.             Tree_QueryTree(yyt->U_1.V_50.Decompose.Patterns);
  6872.           }
  6873.           break;
  6874.         case Tree_VarDef:;
  6875.           if (FALSE) {
  6876.           } else if (yyyIsEqual((STRING)"TypeDesc", 8L)) {
  6877.             Tree_QueryTree(yyt->U_1.V_51.VarDef.TypeDesc);
  6878.           } else if (yyyIsEqual((STRING)"Path", 4L)) {
  6879.             Tree_QueryTree(yyt->U_1.V_51.VarDef.Path);
  6880.           }
  6881.           break;
  6882.         case Tree_NilTest:;
  6883.           if (FALSE) {
  6884.           } else if (yyyIsEqual((STRING)"TypeDesc", 8L)) {
  6885.             Tree_QueryTree(yyt->U_1.V_52.NilTest.TypeDesc);
  6886.           } else if (yyyIsEqual((STRING)"Path", 4L)) {
  6887.             Tree_QueryTree(yyt->U_1.V_52.NilTest.Path);
  6888.           }
  6889.           break;
  6890.         case Tree_DontCare1:;
  6891.           if (FALSE) {
  6892.           } else if (yyyIsEqual((STRING)"TypeDesc", 8L)) {
  6893.             Tree_QueryTree(yyt->U_1.V_53.DontCare1.TypeDesc);
  6894.           } else if (yyyIsEqual((STRING)"Path", 4L)) {
  6895.             Tree_QueryTree(yyt->U_1.V_53.DontCare1.Path);
  6896.           }
  6897.           break;
  6898.         case Tree_DontCare:;
  6899.           if (FALSE) {
  6900.           } else if (yyyIsEqual((STRING)"TypeDesc", 8L)) {
  6901.             Tree_QueryTree(yyt->U_1.V_54.DontCare.TypeDesc);
  6902.           } else if (yyyIsEqual((STRING)"Path", 4L)) {
  6903.             Tree_QueryTree(yyt->U_1.V_54.DontCare.Path);
  6904.           } else if (yyyIsEqual((STRING)"Tempos", 6L)) {
  6905.             Tree_QueryTree(yyt->U_1.V_54.DontCare.Tempos);
  6906.           }
  6907.           break;
  6908.         case Tree_Value:;
  6909.           if (FALSE) {
  6910.           } else if (yyyIsEqual((STRING)"TypeDesc", 8L)) {
  6911.             Tree_QueryTree(yyt->U_1.V_55.Value.TypeDesc);
  6912.           } else if (yyyIsEqual((STRING)"Path", 4L)) {
  6913.             Tree_QueryTree(yyt->U_1.V_55.Value.Path);
  6914.           } else if (yyyIsEqual((STRING)"Expr", 4L)) {
  6915.             Tree_QueryTree(yyt->U_1.V_55.Value.Expr);
  6916.           }
  6917.           break;
  6918.         case Tree_OneExpr:;
  6919.           if (FALSE) {
  6920.           } else if (yyyIsEqual((STRING)"Expr", 4L)) {
  6921.             Tree_QueryTree(yyt->U_1.V_58.OneExpr.Expr);
  6922.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  6923.             Tree_QueryTree(yyt->U_1.V_58.OneExpr.Next);
  6924.           }
  6925.           break;
  6926.         case Tree_NamedExpr:;
  6927.           if (FALSE) {
  6928.           } else if (yyyIsEqual((STRING)"Expr", 4L)) {
  6929.             Tree_QueryTree(yyt->U_1.V_59.NamedExpr.Expr);
  6930.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  6931.             Tree_QueryTree(yyt->U_1.V_59.NamedExpr.Next);
  6932.           }
  6933.           break;
  6934.         case Tree_Compose:;
  6935.           if (FALSE) {
  6936.           } else if (yyyIsEqual((STRING)"Expr", 4L)) {
  6937.             Tree_QueryTree(yyt->U_1.V_61.Compose.Expr);
  6938.           } else if (yyyIsEqual((STRING)"Exprs", 5L)) {
  6939.             Tree_QueryTree(yyt->U_1.V_61.Compose.Exprs);
  6940.           } else if (yyyIsEqual((STRING)"TypeDesc", 8L)) {
  6941.             Tree_QueryTree(yyt->U_1.V_61.Compose.TypeDesc);
  6942.           }
  6943.           break;
  6944.         case Tree_Call:;
  6945.           if (FALSE) {
  6946.           } else if (yyyIsEqual((STRING)"Expr", 4L)) {
  6947.             Tree_QueryTree(yyt->U_1.V_65.Call.Expr);
  6948.           } else if (yyyIsEqual((STRING)"Exprs", 5L)) {
  6949.             Tree_QueryTree(yyt->U_1.V_65.Call.Exprs);
  6950.           } else if (yyyIsEqual((STRING)"Patterns", 8L)) {
  6951.             Tree_QueryTree(yyt->U_1.V_65.Call.Patterns);
  6952.           }
  6953.           break;
  6954.         case Tree_Binary:;
  6955.           if (FALSE) {
  6956.           } else if (yyyIsEqual((STRING)"Lop", 3L)) {
  6957.             Tree_QueryTree(yyt->U_1.V_66.Binary.Lop);
  6958.           } else if (yyyIsEqual((STRING)"Rop", 3L)) {
  6959.             Tree_QueryTree(yyt->U_1.V_66.Binary.Rop);
  6960.           }
  6961.           break;
  6962.         case Tree_PreOperator:;
  6963.           if (FALSE) {
  6964.           } else if (yyyIsEqual((STRING)"Expr", 4L)) {
  6965.             Tree_QueryTree(yyt->U_1.V_67.PreOperator.Expr);
  6966.           }
  6967.           break;
  6968.         case Tree_PostOperator:;
  6969.           if (FALSE) {
  6970.           } else if (yyyIsEqual((STRING)"Expr", 4L)) {
  6971.             Tree_QueryTree(yyt->U_1.V_68.PostOperator.Expr);
  6972.           }
  6973.           break;
  6974.         case Tree_Index:;
  6975.           if (FALSE) {
  6976.           } else if (yyyIsEqual((STRING)"Expr", 4L)) {
  6977.             Tree_QueryTree(yyt->U_1.V_69.Index.Expr);
  6978.           } else if (yyyIsEqual((STRING)"Exprs", 5L)) {
  6979.             Tree_QueryTree(yyt->U_1.V_69.Index.Exprs);
  6980.           }
  6981.           break;
  6982.         case Tree_Parents:;
  6983.           if (FALSE) {
  6984.           } else if (yyyIsEqual((STRING)"Expr", 4L)) {
  6985.             Tree_QueryTree(yyt->U_1.V_70.Parents.Expr);
  6986.           }
  6987.           break;
  6988.         case Tree_TargetExpr:;
  6989.           if (FALSE) {
  6990.           } else if (yyyIsEqual((STRING)"Expr", 4L)) {
  6991.             Tree_QueryTree(yyt->U_1.V_71.TargetExpr.Expr);
  6992.           }
  6993.           break;
  6994.         case Tree_Statement:;
  6995.           if (FALSE) {
  6996.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  6997.             Tree_QueryTree(yyt->U_1.V_75.Statement.Next);
  6998.           }
  6999.           break;
  7000.         case Tree_ProcCall:;
  7001.           if (FALSE) {
  7002.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  7003.             Tree_QueryTree(yyt->U_1.V_76.ProcCall.Next);
  7004.           } else if (yyyIsEqual((STRING)"Call", 4L)) {
  7005.             Tree_QueryTree(yyt->U_1.V_76.ProcCall.Call);
  7006.           }
  7007.           break;
  7008.         case Tree_Condition:;
  7009.           if (FALSE) {
  7010.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  7011.             Tree_QueryTree(yyt->U_1.V_77.Condition.Next);
  7012.           } else if (yyyIsEqual((STRING)"Expr", 4L)) {
  7013.             Tree_QueryTree(yyt->U_1.V_77.Condition.Expr);
  7014.           }
  7015.           break;
  7016.         case Tree_Assignment:;
  7017.           if (FALSE) {
  7018.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  7019.             Tree_QueryTree(yyt->U_1.V_78.Assignment.Next);
  7020.           } else if (yyyIsEqual((STRING)"Adr", 3L)) {
  7021.             Tree_QueryTree(yyt->U_1.V_78.Assignment.Adr);
  7022.           } else if (yyyIsEqual((STRING)"Expr", 4L)) {
  7023.             Tree_QueryTree(yyt->U_1.V_78.Assignment.Expr);
  7024.           }
  7025.           break;
  7026.         case Tree_Reject:;
  7027.           if (FALSE) {
  7028.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  7029.             Tree_QueryTree(yyt->U_1.V_79.Reject.Next);
  7030.           }
  7031.           break;
  7032.         case Tree_Fail:;
  7033.           if (FALSE) {
  7034.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  7035.             Tree_QueryTree(yyt->U_1.V_80.Fail.Next);
  7036.           }
  7037.           break;
  7038.         case Tree_TargetStmt:;
  7039.           if (FALSE) {
  7040.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  7041.             Tree_QueryTree(yyt->U_1.V_81.TargetStmt.Next);
  7042.           } else if (yyyIsEqual((STRING)"Parameters", 10L)) {
  7043.             Tree_QueryTree(yyt->U_1.V_81.TargetStmt.Parameters);
  7044.           } else if (yyyIsEqual((STRING)"Stmt", 4L)) {
  7045.             Tree_QueryTree(yyt->U_1.V_81.TargetStmt.Stmt);
  7046.           }
  7047.           break;
  7048.         case Tree_Nl:;
  7049.           if (FALSE) {
  7050.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  7051.             Tree_QueryTree(yyt->U_1.V_82.Nl.Next);
  7052.           }
  7053.           break;
  7054.         case Tree_WriteStr:;
  7055.           if (FALSE) {
  7056.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  7057.             Tree_QueryTree(yyt->U_1.V_83.WriteStr.Next);
  7058.           }
  7059.           break;
  7060.         case Tree_Formal:;
  7061.           if (FALSE) {
  7062.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  7063.             Tree_QueryTree(yyt->U_1.V_86.Formal.Next);
  7064.           } else if (yyyIsEqual((STRING)"TypeDesc", 8L)) {
  7065.             Tree_QueryTree(yyt->U_1.V_86.Formal.TypeDesc);
  7066.           } else if (yyyIsEqual((STRING)"Path", 4L)) {
  7067.             Tree_QueryTree(yyt->U_1.V_86.Formal.Path);
  7068.           }
  7069.           break;
  7070.         case Tree_DummyFormal:;
  7071.           if (FALSE) {
  7072.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  7073.             Tree_QueryTree(yyt->U_1.V_87.DummyFormal.Next);
  7074.           }
  7075.           break;
  7076.         case Tree_NodeTypes:;
  7077.           if (FALSE) {
  7078.           } else if (yyyIsEqual((STRING)"TreeName", 8L)) {
  7079.             Tree_QueryTree(yyt->U_1.V_89.NodeTypes.TreeName);
  7080.           }
  7081.           break;
  7082.         case Tree_ConsType:;
  7083.           if (FALSE) {
  7084.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  7085.             Tree_QueryTree(yyt->U_1.V_93.ConsType.Next);
  7086.           }
  7087.           break;
  7088.         case Tree_Field:;
  7089.           if (FALSE) {
  7090.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  7091.             Tree_QueryTree(yyt->U_1.V_94.Field.Next);
  7092.           }
  7093.           break;
  7094.         case Tree_OneTest:;
  7095.           if (FALSE) {
  7096.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  7097.             Tree_QueryTree(yyt->U_1.V_97.OneTest.Next);
  7098.           } else if (yyyIsEqual((STRING)"Path", 4L)) {
  7099.             Tree_QueryTree(yyt->U_1.V_97.OneTest.Path);
  7100.           }
  7101.           break;
  7102.         case Tree_TestKind:;
  7103.           if (FALSE) {
  7104.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  7105.             Tree_QueryTree(yyt->U_1.V_98.TestKind.Next);
  7106.           } else if (yyyIsEqual((STRING)"Path", 4L)) {
  7107.             Tree_QueryTree(yyt->U_1.V_98.TestKind.Path);
  7108.           } else if (yyyIsEqual((STRING)"TypeDesc", 8L)) {
  7109.             Tree_QueryTree(yyt->U_1.V_98.TestKind.TypeDesc);
  7110.           }
  7111.           break;
  7112.         case Tree_TestIsType:;
  7113.           if (FALSE) {
  7114.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  7115.             Tree_QueryTree(yyt->U_1.V_99.TestIsType.Next);
  7116.           } else if (yyyIsEqual((STRING)"Path", 4L)) {
  7117.             Tree_QueryTree(yyt->U_1.V_99.TestIsType.Path);
  7118.           } else if (yyyIsEqual((STRING)"TypeDesc", 8L)) {
  7119.             Tree_QueryTree(yyt->U_1.V_99.TestIsType.TypeDesc);
  7120.           }
  7121.           break;
  7122.         case Tree_TestNil:;
  7123.           if (FALSE) {
  7124.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  7125.             Tree_QueryTree(yyt->U_1.V_100.TestNil.Next);
  7126.           } else if (yyyIsEqual((STRING)"Path", 4L)) {
  7127.             Tree_QueryTree(yyt->U_1.V_100.TestNil.Path);
  7128.           }
  7129.           break;
  7130.         case Tree_TestNonlin:;
  7131.           if (FALSE) {
  7132.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  7133.             Tree_QueryTree(yyt->U_1.V_101.TestNonlin.Next);
  7134.           } else if (yyyIsEqual((STRING)"Path", 4L)) {
  7135.             Tree_QueryTree(yyt->U_1.V_101.TestNonlin.Path);
  7136.           } else if (yyyIsEqual((STRING)"Path2", 5L)) {
  7137.             Tree_QueryTree(yyt->U_1.V_101.TestNonlin.Path2);
  7138.           } else if (yyyIsEqual((STRING)"TypeDesc", 8L)) {
  7139.             Tree_QueryTree(yyt->U_1.V_101.TestNonlin.TypeDesc);
  7140.           }
  7141.           break;
  7142.         case Tree_TestValue:;
  7143.           if (FALSE) {
  7144.           } else if (yyyIsEqual((STRING)"Next", 4L)) {
  7145.             Tree_QueryTree(yyt->U_1.V_102.TestValue.Next);
  7146.           } else if (yyyIsEqual((STRING)"Path", 4L)) {
  7147.             Tree_QueryTree(yyt->U_1.V_102.TestValue.Path);
  7148.           } else if (yyyIsEqual((STRING)"Expr", 4L)) {
  7149.             Tree_QueryTree(yyt->U_1.V_102.TestValue.Expr);
  7150.           } else if (yyyIsEqual((STRING)"TypeDesc", 8L)) {
  7151.             Tree_QueryTree(yyt->U_1.V_102.TestValue.TypeDesc);
  7152.           }
  7153.           break;
  7154.         case Tree_Decision:;
  7155.           if (FALSE) {
  7156.           } else if (yyyIsEqual((STRING)"Then", 4L)) {
  7157.             Tree_QueryTree(yyt->U_1.V_105.Decision.Then);
  7158.           } else if (yyyIsEqual((STRING)"Else", 4L)) {
  7159.             Tree_QueryTree(yyt->U_1.V_105.Decision.Else);
  7160.           } else if (yyyIsEqual((STRING)"OneTest", 7L)) {
  7161.             Tree_QueryTree(yyt->U_1.V_105.Decision.OneTest);
  7162.           }
  7163.           break;
  7164.         case Tree_Decided:;
  7165.           if (FALSE) {
  7166.           } else if (yyyIsEqual((STRING)"Else", 4L)) {
  7167.             Tree_QueryTree(yyt->U_1.V_106.Decided.Else);
  7168.           } else if (yyyIsEqual((STRING)"Rule", 4L)) {
  7169.             Tree_QueryTree(yyt->U_1.V_106.Decided.Rule);
  7170.           }
  7171.           break;
  7172.         default :
  7173.           break;
  7174.         }
  7175.       }
  7176.       break;
  7177.     }
  7178.   } EXIT_6:;
  7179. }
  7180.  
  7181. void Tree_BeginTree
  7182. # ifdef __STDC__
  7183. ()
  7184. # else
  7185. ()
  7186. # endif
  7187. {
  7188.   Tree_ErrorCount = 0;
  7189.   Sets_MakeSet(&Tree_Options, 127L);
  7190.   Tree_NoCodeAttr = SET_ELEM(Tree_Test) | SET_ELEM(Tree_Dummy) | SET_ELEM(Tree_Virtual) | SET_ELEM(Tree_Parameter);
  7191.   Tree_NoCodeClass = SET_ELEM(Tree_Ignore) | SET_ELEM(Tree_Abstract);
  7192. }
  7193.  
  7194. void Tree_CloseTree
  7195. # ifdef __STDC__
  7196. ()
  7197. # else
  7198. ()
  7199. # endif
  7200. {
  7201. }
  7202.  
  7203. static void xxExit
  7204. # ifdef __STDC__
  7205. ()
  7206. # else
  7207. ()
  7208. # endif
  7209. {
  7210.   IO_CloseIO();
  7211.   Exit(1L);
  7212. }
  7213.  
  7214. void BEGIN_Tree()
  7215. {
  7216.   static BOOLEAN has_been_called = FALSE;
  7217.  
  7218.   if (!has_been_called) {
  7219.     has_been_called = TRUE;
  7220.  
  7221.     BEGIN_IO();
  7222.     BEGIN_IO();
  7223.     BEGIN_Strings();
  7224.     BEGIN_StringMem();
  7225.     BEGIN_Idents();
  7226.     BEGIN_Texts();
  7227.     BEGIN_Sets();
  7228.     BEGIN_Relations();
  7229.     BEGIN_Positions();
  7230.     BEGIN_System();
  7231.     BEGIN_General();
  7232.     BEGIN_Memory();
  7233.     BEGIN_DynArray();
  7234.     BEGIN_IO();
  7235.     BEGIN_Layout();
  7236.     BEGIN_StringMem();
  7237.     BEGIN_Strings();
  7238.     BEGIN_Idents();
  7239.     BEGIN_Texts();
  7240.     BEGIN_Sets();
  7241.     BEGIN_Positions();
  7242.     BEGIN_DynArray();
  7243.     BEGIN_IO();
  7244.     BEGIN_Strings();
  7245.     BEGIN_StringMem();
  7246.     BEGIN_Idents();
  7247.     BEGIN_Texts();
  7248.     BEGIN_Sets();
  7249.     BEGIN_Relations();
  7250.     BEGIN_Positions();
  7251.     BEGIN_Relations();
  7252.     BEGIN_Errors();
  7253.  
  7254.     yyBlockList = NIL;
  7255.     Tree_yyPoolFreePtr = (ADDRESS)NIL;
  7256.     Tree_yyPoolMaxPtr = (ADDRESS)NIL;
  7257.     Tree_HeapUsed = 0;
  7258.     Tree_yyExit = xxExit;
  7259.     Tree_yyNodeSize.A[Tree_Classes] = sizeof(Tree_yClasses);
  7260.     Tree_yyNodeSize.A[Tree_NoClass] = sizeof(Tree_yNoClass);
  7261.     Tree_yyNodeSize.A[Tree_Class] = sizeof(Tree_yClass);
  7262.     Tree_yyNodeSize.A[Tree_Attributes] = sizeof(Tree_yAttributes);
  7263.     Tree_yyNodeSize.A[Tree_NoAttribute] = sizeof(Tree_yNoAttribute);
  7264.     Tree_yyNodeSize.A[Tree_AttrOrAction] = sizeof(Tree_yAttrOrAction);
  7265.     Tree_yyNodeSize.A[Tree_Child] = sizeof(Tree_yChild);
  7266.     Tree_yyNodeSize.A[Tree_Attribute] = sizeof(Tree_yAttribute);
  7267.     Tree_yyNodeSize.A[Tree_ActionPart] = sizeof(Tree_yActionPart);
  7268.     Tree_yyNodeSize.A[Tree_Codes] = sizeof(Tree_yCodes);
  7269.     Tree_yyNodeSize.A[Tree_Designators] = sizeof(Tree_yDesignators);
  7270.     Tree_yyNodeSize.A[Tree_NoDesignator] = sizeof(Tree_yNoDesignator);
  7271.     Tree_yyNodeSize.A[Tree_Designator] = sizeof(Tree_yDesignator);
  7272.     Tree_yyNodeSize.A[Tree_Ident] = sizeof(Tree_yIdent);
  7273.     Tree_yyNodeSize.A[Tree_Remote] = sizeof(Tree_yRemote);
  7274.     Tree_yyNodeSize.A[Tree_Any] = sizeof(Tree_yAny);
  7275.     Tree_yyNodeSize.A[Tree_Anys] = sizeof(Tree_yAnys);
  7276.     Tree_yyNodeSize.A[Tree_Layouts] = sizeof(Tree_yLayouts);
  7277.     Tree_yyNodeSize.A[Tree_NoLayout] = sizeof(Tree_yNoLayout);
  7278.     Tree_yyNodeSize.A[Tree_LayoutAny] = sizeof(Tree_yLayoutAny);
  7279.     Tree_yyNodeSize.A[Tree_Names] = sizeof(Tree_yNames);
  7280.     Tree_yyNodeSize.A[Tree_NoName] = sizeof(Tree_yNoName);
  7281.     Tree_yyNodeSize.A[Tree_Name] = sizeof(Tree_yName);
  7282.     Tree_yyNodeSize.A[Tree_Spec] = sizeof(Tree_ySpec);
  7283.     Tree_yyNodeSize.A[Tree_TreeNames] = sizeof(Tree_yTreeNames);
  7284.     Tree_yyNodeSize.A[Tree_NoTreeName] = sizeof(Tree_yNoTreeName);
  7285.     Tree_yyNodeSize.A[Tree_TreeName] = sizeof(Tree_yTreeName);
  7286.     Tree_yyNodeSize.A[Tree_Routines] = sizeof(Tree_yRoutines);
  7287.     Tree_yyNodeSize.A[Tree_NoRoutine] = sizeof(Tree_yNoRoutine);
  7288.     Tree_yyNodeSize.A[Tree_Routine] = sizeof(Tree_yRoutine);
  7289.     Tree_yyNodeSize.A[Tree_Procedure] = sizeof(Tree_yProcedure);
  7290.     Tree_yyNodeSize.A[Tree_Function] = sizeof(Tree_yFunction);
  7291.     Tree_yyNodeSize.A[Tree_Predicate] = sizeof(Tree_yPredicate);
  7292.     Tree_yyNodeSize.A[Tree_Parameters] = sizeof(Tree_yParameters);
  7293.     Tree_yyNodeSize.A[Tree_NoParameter] = sizeof(Tree_yNoParameter);
  7294.     Tree_yyNodeSize.A[Tree_Param] = sizeof(Tree_yParam);
  7295.     Tree_yyNodeSize.A[Tree_Type] = sizeof(Tree_yType);
  7296.     Tree_yyNodeSize.A[Tree_Rules] = sizeof(Tree_yRules);
  7297.     Tree_yyNodeSize.A[Tree_NoRule] = sizeof(Tree_yNoRule);
  7298.     Tree_yyNodeSize.A[Tree_Rule] = sizeof(Tree_yRule);
  7299.     Tree_yyNodeSize.A[Tree_Patterns] = sizeof(Tree_yPatterns);
  7300.     Tree_yyNodeSize.A[Tree_NoPattern] = sizeof(Tree_yNoPattern);
  7301.     Tree_yyNodeSize.A[Tree_OnePattern] = sizeof(Tree_yOnePattern);
  7302.     Tree_yyNodeSize.A[Tree_PatternsList] = sizeof(Tree_yPatternsList);
  7303.     Tree_yyNodeSize.A[Tree_NoPatternsList] = sizeof(Tree_yNoPatternsList);
  7304.     Tree_yyNodeSize.A[Tree_OnePatternsList] = sizeof(Tree_yOnePatternsList);
  7305.     Tree_yyNodeSize.A[Tree_Pattern] = sizeof(Tree_yPattern);
  7306.     Tree_yyNodeSize.A[Tree_Decompose] = sizeof(Tree_yDecompose);
  7307.     Tree_yyNodeSize.A[Tree_VarDef] = sizeof(Tree_yVarDef);
  7308.     Tree_yyNodeSize.A[Tree_NilTest] = sizeof(Tree_yNilTest);
  7309.     Tree_yyNodeSize.A[Tree_DontCare1] = sizeof(Tree_yDontCare1);
  7310.     Tree_yyNodeSize.A[Tree_DontCare] = sizeof(Tree_yDontCare);
  7311.     Tree_yyNodeSize.A[Tree_Value] = sizeof(Tree_yValue);
  7312.     Tree_yyNodeSize.A[Tree_Exprs] = sizeof(Tree_yExprs);
  7313.     Tree_yyNodeSize.A[Tree_NoExpr] = sizeof(Tree_yNoExpr);
  7314.     Tree_yyNodeSize.A[Tree_OneExpr] = sizeof(Tree_yOneExpr);
  7315.     Tree_yyNodeSize.A[Tree_NamedExpr] = sizeof(Tree_yNamedExpr);
  7316.     Tree_yyNodeSize.A[Tree_Expr] = sizeof(Tree_yExpr);
  7317.     Tree_yyNodeSize.A[Tree_Compose] = sizeof(Tree_yCompose);
  7318.     Tree_yyNodeSize.A[Tree_VarUse] = sizeof(Tree_yVarUse);
  7319.     Tree_yyNodeSize.A[Tree_AttrDesc] = sizeof(Tree_yAttrDesc);
  7320.     Tree_yyNodeSize.A[Tree_Nil] = sizeof(Tree_yNil);
  7321.     Tree_yyNodeSize.A[Tree_Call] = sizeof(Tree_yCall);
  7322.     Tree_yyNodeSize.A[Tree_Binary] = sizeof(Tree_yBinary);
  7323.     Tree_yyNodeSize.A[Tree_PreOperator] = sizeof(Tree_yPreOperator);
  7324.     Tree_yyNodeSize.A[Tree_PostOperator] = sizeof(Tree_yPostOperator);
  7325.     Tree_yyNodeSize.A[Tree_Index] = sizeof(Tree_yIndex);
  7326.     Tree_yyNodeSize.A[Tree_Parents] = sizeof(Tree_yParents);
  7327.     Tree_yyNodeSize.A[Tree_TargetExpr] = sizeof(Tree_yTargetExpr);
  7328.     Tree_yyNodeSize.A[Tree_StringExpr] = sizeof(Tree_yStringExpr);
  7329.     Tree_yyNodeSize.A[Tree_Statements] = sizeof(Tree_yStatements);
  7330.     Tree_yyNodeSize.A[Tree_NoStatement] = sizeof(Tree_yNoStatement);
  7331.     Tree_yyNodeSize.A[Tree_Statement] = sizeof(Tree_yStatement);
  7332.     Tree_yyNodeSize.A[Tree_ProcCall] = sizeof(Tree_yProcCall);
  7333.     Tree_yyNodeSize.A[Tree_Condition] = sizeof(Tree_yCondition);
  7334.     Tree_yyNodeSize.A[Tree_Assignment] = sizeof(Tree_yAssignment);
  7335.     Tree_yyNodeSize.A[Tree_Reject] = sizeof(Tree_yReject);
  7336.     Tree_yyNodeSize.A[Tree_Fail] = sizeof(Tree_yFail);
  7337.     Tree_yyNodeSize.A[Tree_TargetStmt] = sizeof(Tree_yTargetStmt);
  7338.     Tree_yyNodeSize.A[Tree_Nl] = sizeof(Tree_yNl);
  7339.     Tree_yyNodeSize.A[Tree_WriteStr] = sizeof(Tree_yWriteStr);
  7340.     Tree_yyNodeSize.A[Tree_Formals] = sizeof(Tree_yFormals);
  7341.     Tree_yyNodeSize.A[Tree_NoFormal] = sizeof(Tree_yNoFormal);
  7342.     Tree_yyNodeSize.A[Tree_Formal] = sizeof(Tree_yFormal);
  7343.     Tree_yyNodeSize.A[Tree_DummyFormal] = sizeof(Tree_yDummyFormal);
  7344.     Tree_yyNodeSize.A[Tree_TypeDesc] = sizeof(Tree_yTypeDesc);
  7345.     Tree_yyNodeSize.A[Tree_NodeTypes] = sizeof(Tree_yNodeTypes);
  7346.     Tree_yyNodeSize.A[Tree_UserType] = sizeof(Tree_yUserType);
  7347.     Tree_yyNodeSize.A[Tree_Path] = sizeof(Tree_yPath);
  7348.     Tree_yyNodeSize.A[Tree_Var] = sizeof(Tree_yVar);
  7349.     Tree_yyNodeSize.A[Tree_ConsType] = sizeof(Tree_yConsType);
  7350.     Tree_yyNodeSize.A[Tree_Field] = sizeof(Tree_yField);
  7351.     Tree_yyNodeSize.A[Tree_Tests] = sizeof(Tree_yTests);
  7352.     Tree_yyNodeSize.A[Tree_NoTest] = sizeof(Tree_yNoTest);
  7353.     Tree_yyNodeSize.A[Tree_OneTest] = sizeof(Tree_yOneTest);
  7354.     Tree_yyNodeSize.A[Tree_TestKind] = sizeof(Tree_yTestKind);
  7355.     Tree_yyNodeSize.A[Tree_TestIsType] = sizeof(Tree_yTestIsType);
  7356.     Tree_yyNodeSize.A[Tree_TestNil] = sizeof(Tree_yTestNil);
  7357.     Tree_yyNodeSize.A[Tree_TestNonlin] = sizeof(Tree_yTestNonlin);
  7358.     Tree_yyNodeSize.A[Tree_TestValue] = sizeof(Tree_yTestValue);
  7359.     Tree_yyNodeSize.A[Tree_Decisions] = sizeof(Tree_yDecisions);
  7360.     Tree_yyNodeSize.A[Tree_NoDecision] = sizeof(Tree_yNoDecision);
  7361.     Tree_yyNodeSize.A[Tree_Decision] = sizeof(Tree_yDecision);
  7362.     Tree_yyNodeSize.A[Tree_Decided] = sizeof(Tree_yDecided);
  7363.     yyMaxSize = 0;
  7364.     for (yyi = 1; yyi <= 129; yyi += 1) {
  7365.       Tree_yyNodeSize.A[yyi] = (LONGINT)((BITSET)(Tree_yyNodeSize.A[yyi] + (CARDINAL)General_MaxAlign - 1) & General_AlignMasks.A[General_MaxAlign]);
  7366.       yyMaxSize = General_Max((LONGINT)Tree_yyNodeSize.A[yyi], (LONGINT)yyMaxSize);
  7367.     }
  7368.     yyTypeRange.A[Tree_Classes] = Tree_Class;
  7369.     yyTypeRange.A[Tree_NoClass] = Tree_NoClass;
  7370.     yyTypeRange.A[Tree_Class] = Tree_Class;
  7371.     yyTypeRange.A[Tree_Attributes] = Tree_ActionPart;
  7372.     yyTypeRange.A[Tree_NoAttribute] = Tree_NoAttribute;
  7373.     yyTypeRange.A[Tree_AttrOrAction] = Tree_ActionPart;
  7374.     yyTypeRange.A[Tree_Child] = Tree_Child;
  7375.     yyTypeRange.A[Tree_Attribute] = Tree_Attribute;
  7376.     yyTypeRange.A[Tree_ActionPart] = Tree_ActionPart;
  7377.     yyTypeRange.A[Tree_Codes] = Tree_Codes;
  7378.     yyTypeRange.A[Tree_Designators] = Tree_Anys;
  7379.     yyTypeRange.A[Tree_NoDesignator] = Tree_NoDesignator;
  7380.     yyTypeRange.A[Tree_Designator] = Tree_Designator;
  7381.     yyTypeRange.A[Tree_Ident] = Tree_Ident;
  7382.     yyTypeRange.A[Tree_Remote] = Tree_Remote;
  7383.     yyTypeRange.A[Tree_Any] = Tree_Any;
  7384.     yyTypeRange.A[Tree_Anys] = Tree_Anys;
  7385.     yyTypeRange.A[Tree_Layouts] = Tree_LayoutAny;
  7386.     yyTypeRange.A[Tree_NoLayout] = Tree_NoLayout;
  7387.     yyTypeRange.A[Tree_LayoutAny] = Tree_LayoutAny;
  7388.     yyTypeRange.A[Tree_Names] = Tree_Name;
  7389.     yyTypeRange.A[Tree_NoName] = Tree_NoName;
  7390.     yyTypeRange.A[Tree_Name] = Tree_Name;
  7391.     yyTypeRange.A[Tree_Spec] = Tree_Spec;
  7392.     yyTypeRange.A[Tree_TreeNames] = Tree_TreeName;
  7393.     yyTypeRange.A[Tree_NoTreeName] = Tree_NoTreeName;
  7394.     yyTypeRange.A[Tree_TreeName] = Tree_TreeName;
  7395.     yyTypeRange.A[Tree_Routines] = Tree_Predicate;
  7396.     yyTypeRange.A[Tree_NoRoutine] = Tree_NoRoutine;
  7397.     yyTypeRange.A[Tree_Routine] = Tree_Predicate;
  7398.     yyTypeRange.A[Tree_Procedure] = Tree_Procedure;
  7399.     yyTypeRange.A[Tree_Function] = Tree_Function;
  7400.     yyTypeRange.A[Tree_Predicate] = Tree_Predicate;
  7401.     yyTypeRange.A[Tree_Parameters] = Tree_Param;
  7402.     yyTypeRange.A[Tree_NoParameter] = Tree_NoParameter;
  7403.     yyTypeRange.A[Tree_Param] = Tree_Param;
  7404.     yyTypeRange.A[Tree_Type] = Tree_Type;
  7405.     yyTypeRange.A[Tree_Rules] = Tree_Rule;
  7406.     yyTypeRange.A[Tree_NoRule] = Tree_NoRule;
  7407.     yyTypeRange.A[Tree_Rule] = Tree_Rule;
  7408.     yyTypeRange.A[Tree_Patterns] = Tree_OnePattern;
  7409.     yyTypeRange.A[Tree_NoPattern] = Tree_NoPattern;
  7410.     yyTypeRange.A[Tree_OnePattern] = Tree_OnePattern;
  7411.     yyTypeRange.A[Tree_PatternsList] = Tree_OnePatternsList;
  7412.     yyTypeRange.A[Tree_NoPatternsList] = Tree_NoPatternsList;
  7413.     yyTypeRange.A[Tree_OnePatternsList] = Tree_OnePatternsList;
  7414.     yyTypeRange.A[Tree_Pattern] = Tree_Value;
  7415.     yyTypeRange.A[Tree_Decompose] = Tree_Decompose;
  7416.     yyTypeRange.A[Tree_VarDef] = Tree_VarDef;
  7417.     yyTypeRange.A[Tree_NilTest] = Tree_NilTest;
  7418.     yyTypeRange.A[Tree_DontCare1] = Tree_DontCare1;
  7419.     yyTypeRange.A[Tree_DontCare] = Tree_DontCare;
  7420.     yyTypeRange.A[Tree_Value] = Tree_Value;
  7421.     yyTypeRange.A[Tree_Exprs] = Tree_NamedExpr;
  7422.     yyTypeRange.A[Tree_NoExpr] = Tree_NoExpr;
  7423.     yyTypeRange.A[Tree_OneExpr] = Tree_NamedExpr;
  7424.     yyTypeRange.A[Tree_NamedExpr] = Tree_NamedExpr;
  7425.     yyTypeRange.A[Tree_Expr] = Tree_StringExpr;
  7426.     yyTypeRange.A[Tree_Compose] = Tree_Compose;
  7427.     yyTypeRange.A[Tree_VarUse] = Tree_AttrDesc;
  7428.     yyTypeRange.A[Tree_AttrDesc] = Tree_AttrDesc;
  7429.     yyTypeRange.A[Tree_Nil] = Tree_Nil;
  7430.     yyTypeRange.A[Tree_Call] = Tree_Call;
  7431.     yyTypeRange.A[Tree_Binary] = Tree_Binary;
  7432.     yyTypeRange.A[Tree_PreOperator] = Tree_PreOperator;
  7433.     yyTypeRange.A[Tree_PostOperator] = Tree_PostOperator;
  7434.     yyTypeRange.A[Tree_Index] = Tree_Index;
  7435.     yyTypeRange.A[Tree_Parents] = Tree_Parents;
  7436.     yyTypeRange.A[Tree_TargetExpr] = Tree_TargetExpr;
  7437.     yyTypeRange.A[Tree_StringExpr] = Tree_StringExpr;
  7438.     yyTypeRange.A[Tree_Statements] = Tree_WriteStr;
  7439.     yyTypeRange.A[Tree_NoStatement] = Tree_NoStatement;
  7440.     yyTypeRange.A[Tree_Statement] = Tree_WriteStr;
  7441.     yyTypeRange.A[Tree_ProcCall] = Tree_ProcCall;
  7442.     yyTypeRange.A[Tree_Condition] = Tree_Condition;
  7443.     yyTypeRange.A[Tree_Assignment] = Tree_Assignment;
  7444.     yyTypeRange.A[Tree_Reject] = Tree_Reject;
  7445.     yyTypeRange.A[Tree_Fail] = Tree_Fail;
  7446.     yyTypeRange.A[Tree_TargetStmt] = Tree_TargetStmt;
  7447.     yyTypeRange.A[Tree_Nl] = Tree_Nl;
  7448.     yyTypeRange.A[Tree_WriteStr] = Tree_WriteStr;
  7449.     yyTypeRange.A[Tree_Formals] = Tree_DummyFormal;
  7450.     yyTypeRange.A[Tree_NoFormal] = Tree_NoFormal;
  7451.     yyTypeRange.A[Tree_Formal] = Tree_Formal;
  7452.     yyTypeRange.A[Tree_DummyFormal] = Tree_DummyFormal;
  7453.     yyTypeRange.A[Tree_TypeDesc] = Tree_UserType;
  7454.     yyTypeRange.A[Tree_NodeTypes] = Tree_NodeTypes;
  7455.     yyTypeRange.A[Tree_UserType] = Tree_UserType;
  7456.     yyTypeRange.A[Tree_Path] = Tree_Field;
  7457.     yyTypeRange.A[Tree_Var] = Tree_Var;
  7458.     yyTypeRange.A[Tree_ConsType] = Tree_ConsType;
  7459.     yyTypeRange.A[Tree_Field] = Tree_Field;
  7460.     yyTypeRange.A[Tree_Tests] = Tree_TestValue;
  7461.     yyTypeRange.A[Tree_NoTest] = Tree_NoTest;
  7462.     yyTypeRange.A[Tree_OneTest] = Tree_TestValue;
  7463.     yyTypeRange.A[Tree_TestKind] = Tree_TestKind;
  7464.     yyTypeRange.A[Tree_TestIsType] = Tree_TestIsType;
  7465.     yyTypeRange.A[Tree_TestNil] = Tree_TestNil;
  7466.     yyTypeRange.A[Tree_TestNonlin] = Tree_TestNonlin;
  7467.     yyTypeRange.A[Tree_TestValue] = Tree_TestValue;
  7468.     yyTypeRange.A[Tree_Decisions] = Tree_Decided;
  7469.     yyTypeRange.A[Tree_NoDecision] = Tree_NoDecision;
  7470.     yyTypeRange.A[Tree_Decision] = Tree_Decision;
  7471.     yyTypeRange.A[Tree_Decided] = Tree_Decided;
  7472.     yyOldToNewStoreSize = yyInitOldToNewStoreSize;
  7473.     DynArray_MakeArray((ADDRESS *)&yyOldToNewStorePtr, &yyOldToNewStoreSize, (LONGINT)sizeof(yytOldToNew));
  7474.     Tree_BeginTree();
  7475.   }
  7476. }
  7477.